{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = \"./datasets/ml-latest-small/ratings.csv\"\n",
    "CACHE_DIR = './datasets/cache'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   userId  movieId  rating\n",
      "0       1        1     4.0\n",
      "1       1        3     4.0\n",
      "2       1        6     4.0\n",
      "3       1       47     5.0\n",
      "4       1       50     5.0\n",
      "5       1       70     3.0\n",
      "6       1      101     5.0\n",
      "7       1      110     4.0\n",
      "8       1      151     5.0\n",
      "9       1      157     5.0\n",
      "movieId   1    2    3    4    5    6    7    8   9    10\n",
      "userId                                                  \n",
      "1        4.0  NaN  4.0  NaN  NaN  4.0  NaN  NaN NaN  NaN\n",
      "2        NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN NaN  NaN\n",
      "3        NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN NaN  NaN\n",
      "4        NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN NaN  NaN\n",
      "5        4.0  NaN  NaN  NaN  NaN  NaN  NaN  NaN NaN  NaN\n",
      "6        NaN  4.0  5.0  3.0  5.0  4.0  4.0  3.0 NaN  3.0\n",
      "7        4.5  NaN  NaN  NaN  NaN  NaN  NaN  NaN NaN  NaN\n",
      "8        NaN  4.0  NaN  NaN  NaN  NaN  NaN  NaN NaN  2.0\n",
      "9        NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN NaN  NaN\n",
      "10       NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN NaN  NaN\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 100836 entries, 0 to 100835\n",
      "Data columns (total 3 columns):\n",
      "userId     100836 non-null int64\n",
      "movieId    100836 non-null int64\n",
      "rating     100836 non-null float64\n",
      "dtypes: float64(1), int64(2)\n",
      "memory usage: 2.3 MB\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 610 entries, 1 to 610\n",
      "Columns: 9724 entries, 1 to 193609\n",
      "dtypes: float64(9724)\n",
      "memory usage: 45.3 MB\n"
     ]
    }
   ],
   "source": [
    "datasets = pd.read_csv(\"./datasets/ml-latest-small/ratings.csv\",usecols=range(3))\n",
    "print(datasets.head(10))\n",
    "\n",
    "datasets_matrix = datasets.pivot_table(index=['userId'],columns=['movieId'],values='rating')\n",
    "print(datasets_matrix.iloc[:10,:10])\n",
    "\n",
    "datasets.info()\n",
    "datasets_matrix.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始加载数据...\n",
      "加载缓存中...\n",
      "从缓存中加载数据完毕...\n",
      "movieId  1       2       3       4       5       6       7       8       \\\n",
      "userId                                                                    \n",
      "1           4.0     NaN     4.0     NaN     NaN     4.0     NaN     NaN   \n",
      "2           NaN     NaN     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "3           NaN     NaN     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "4           NaN     NaN     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "5           4.0     NaN     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "...         ...     ...     ...     ...     ...     ...     ...     ...   \n",
      "606         2.5     NaN     NaN     NaN     NaN     NaN     2.5     NaN   \n",
      "607         4.0     NaN     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "608         2.5     2.0     2.0     NaN     NaN     NaN     NaN     NaN   \n",
      "609         3.0     NaN     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "610         5.0     NaN     NaN     NaN     NaN     5.0     NaN     NaN   \n",
      "\n",
      "movieId  9       10      ...  193565  193567  193571  193573  193579  193581  \\\n",
      "userId                   ...                                                   \n",
      "1           NaN     NaN  ...     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "2           NaN     NaN  ...     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "3           NaN     NaN  ...     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "4           NaN     NaN  ...     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "5           NaN     NaN  ...     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "...         ...     ...  ...     ...     ...     ...     ...     ...     ...   \n",
      "606         NaN     NaN  ...     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "607         NaN     NaN  ...     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "608         NaN     4.0  ...     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "609         NaN     4.0  ...     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "610         NaN     NaN  ...     NaN     NaN     NaN     NaN     NaN     NaN   \n",
      "\n",
      "movieId  193583  193585  193587  193609  \n",
      "userId                                   \n",
      "1           NaN     NaN     NaN     NaN  \n",
      "2           NaN     NaN     NaN     NaN  \n",
      "3           NaN     NaN     NaN     NaN  \n",
      "4           NaN     NaN     NaN     NaN  \n",
      "5           NaN     NaN     NaN     NaN  \n",
      "...         ...     ...     ...     ...  \n",
      "606         NaN     NaN     NaN     NaN  \n",
      "607         NaN     NaN     NaN     NaN  \n",
      "608         NaN     NaN     NaN     NaN  \n",
      "609         NaN     NaN     NaN     NaN  \n",
      "610         NaN     NaN     NaN     NaN  \n",
      "\n",
      "[610 rows x 9724 columns]\n"
     ]
    }
   ],
   "source": [
    "def load_data(data_path):\n",
    "    '''\n",
    "    加载数据\n",
    "    :param data_path :数据路径\n",
    "    :param cache_path:数据缓存路径\n",
    "    :return :用户-物品评分矩阵\n",
    "    '''\n",
    "    cache_path = os.path.join(CACHE_DIR,\"ratings_matrix.cache\")\n",
    "    \n",
    "    print(\"开始加载数据...\")\n",
    "    if os.path.exists(cache_path):\n",
    "        print(\"加载缓存中...\")\n",
    "        rating_matrix = pd.read_pickle(cache_path)#用read_pickle读取数据\n",
    "        print(\"从缓存中加载数据完毕...\")\n",
    "    else:\n",
    "        print(\"加载新数据中...\")\n",
    "        dtype = {\"userId\":np.int32,\"movieId\":np.int32,\"rating\":np.float32}#设置字段类型\n",
    "        rating = pd.read_csv(data_path,dtype = dtype,usecols=range(3))#usecol表示加载前三个字段\n",
    "        #pivot_table 透视表 把原来 每条数据代表一个用户对一部电源的评分 转换为一个用户对所有\n",
    "        rating_matrix = rating.pivot_table(index=['userId'],columns=['movieId'],values='rating')\n",
    "        rating_matrix.to_pickle(cache_path)#保存到缓存中\n",
    "        print(\"数据加载完毕\")\n",
    "    return rating_matrix\n",
    "        \n",
    "if __name__ == '__main__':\n",
    "    rating_matrix = load_data(DATA_PATH)\n",
    "    print(rating_matrix)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "userId         1         2         3         4         5         6         7\n",
      "userId                                                                      \n",
      "1       1.000000       NaN  0.079819  0.207983  0.268749 -0.291636 -0.118773\n",
      "2            NaN  1.000000       NaN       NaN       NaN       NaN -0.991241\n",
      "3       0.079819       NaN  1.000000       NaN       NaN       NaN       NaN\n",
      "4       0.207983       NaN       NaN  1.000000 -0.336525  0.148498  0.542861\n",
      "5       0.268749       NaN       NaN -0.336525  1.000000  0.043166  0.158114\n",
      "6      -0.291636       NaN       NaN  0.148498  0.043166  1.000000 -0.126595\n",
      "7      -0.118773 -0.991241       NaN  0.542861  0.158114 -0.126595  1.000000\n",
      "8       0.469668       NaN       NaN  0.117851  0.028347 -0.200062  0.220416\n",
      "9       0.918559       NaN       NaN       NaN       NaN       NaN  0.925000\n",
      "10     -0.037987  0.037796       NaN  0.485794 -0.777714  0.957427 -0.156764\n"
     ]
    }
   ],
   "source": [
    "us_similarity = datasets_matrix.T.corr()\n",
    "print(us_similarity.iloc[:10,:7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始加载数据...\n",
      "加载缓存中...\n",
      "从缓存中加载数据完毕...\n",
      "从缓存中加载用户相似度矩阵\n",
      "相似度矩阵处理完毕\n",
      "从缓存中加载物品相似度矩阵\n",
      "相似度矩阵处理完毕\n",
      "userId         1         2         3         4         5         6         7\n",
      "userId                                                                      \n",
      "1       1.000000       NaN  0.079819  0.207983  0.268749 -0.291636 -0.118773\n",
      "2            NaN  1.000000       NaN       NaN       NaN       NaN -0.991241\n",
      "3       0.079819       NaN  1.000000       NaN       NaN       NaN       NaN\n",
      "4       0.207983       NaN       NaN  1.000000 -0.336525  0.148498  0.542861\n",
      "5       0.268749       NaN       NaN -0.336525  1.000000  0.043166  0.158114\n",
      "6      -0.291636       NaN       NaN  0.148498  0.043166  1.000000 -0.126595\n",
      "7      -0.118773 -0.991241       NaN  0.542861  0.158114 -0.126595  1.000000\n",
      "8       0.469668       NaN       NaN  0.117851  0.028347 -0.200062  0.220416\n",
      "9       0.918559       NaN       NaN       NaN       NaN       NaN  0.925000\n",
      "10     -0.037987  0.037796       NaN  0.485794 -0.777714  0.957427 -0.156764\n",
      "movieId         1         2         3         4         5         6         7\n",
      "movieId                                                                      \n",
      "1        1.000000  0.330978  0.487109  1.000000  0.310971  0.106465  0.208402\n",
      "2        0.330978  1.000000  0.419564       NaN  0.562791  0.163510  0.430261\n",
      "3        0.487109  0.419564  1.000000       NaN  0.602266  0.345069  0.554088\n",
      "4        1.000000       NaN       NaN  1.000000  0.654654       NaN  0.203653\n",
      "5        0.310971  0.562791  0.602266  0.654654  1.000000  0.291302  0.609119\n",
      "6        0.106465  0.163510  0.345069       NaN  0.291302  1.000000 -0.123897\n",
      "7        0.208402  0.430261  0.554088  0.203653  0.609119 -0.123897  1.000000\n",
      "8        0.968246  0.415227  0.333333       NaN  0.555556 -0.801784  0.816497\n",
      "9        0.095913  0.277350  0.458591       NaN  0.319173 -0.172891  0.745356\n",
      "10      -0.021409  0.016626 -0.050276  0.870388  0.218263  0.420222  0.186891\n"
     ]
    }
   ],
   "source": [
    "def compute_pearson_similarity(rating_matrix,based = 'user'):\n",
    "    '''\n",
    "    计算皮尔逊相关系数\n",
    "    :param rating_matrix : 用户-物品评分矩阵\n",
    "    :param baed : user or item\n",
    "    :return :相似度矩阵\n",
    "    '''\n",
    "    user_similarity_cache_path = os.path.join(CACHE_DIR,'user_similarity.cache')\n",
    "    item_similarity_cache_path = os.path.join(CACHE_DIR,'item_similarity.cache')\n",
    "    \n",
    "    if based == 'user':\n",
    "        if os.path.exists(user_similarity_cache_path):\n",
    "            print(\"从缓存中加载用户相似度矩阵\")\n",
    "            similarity = pd.read_pickle(user_similarity_cache_path)\n",
    "        else:\n",
    "            print(\"开始计算用户相似度矩阵\")\n",
    "            similarity = rating_matrix.T.corr()\n",
    "            similarity.to_pickle(user_similarity_cache_path)\n",
    "    elif based == 'item':\n",
    "        if os.path.exists(item_similarity_cache_path):\n",
    "            print(\"从缓存中加载物品相似度矩阵\")\n",
    "            similarity = pd.read_pickle(item_similarity_cache_path)\n",
    "        else:\n",
    "            print(\"开始计算物品相似度矩阵\")\n",
    "            similarity = rating_matrix.corr()\n",
    "            similarity.to_pickle(item_similarity_cache_path)\n",
    "    else:\n",
    "        raise Exception(\"unhandled Value\")\n",
    "        \n",
    "    print(\"相似度矩阵处理完毕\")\n",
    "    return similarity\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    rating_matrix = load_data(DATA_PATH)\n",
    "    user_similar = compute_pearson_similarity(rating_matrix,based='user')\n",
    "    item_similar = compute_pearson_similarity(rating_matrix,based='item')\n",
    "    print(user_similar.iloc[:10,:7])\n",
    "    print(item_similar.iloc[:10,:7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "userId\n",
      "3      0.079819\n",
      "4      0.207983\n",
      "5      0.268749\n",
      "8      0.469668\n",
      "9      0.918559\n",
      "         ...   \n",
      "600    0.253649\n",
      "601    0.091574\n",
      "606    0.066378\n",
      "607    0.174557\n",
      "608    0.268070\n",
      "Name: 1, Length: 377, dtype: float64\n",
      "userId\n",
      "8      0.469668\n",
      "18     0.205371\n",
      "19     0.325180\n",
      "20     0.419641\n",
      "21     0.107119\n",
      "         ...   \n",
      "590    0.311182\n",
      "594    0.198460\n",
      "599    0.219768\n",
      "600    0.253649\n",
      "608    0.268070\n",
      "Name: 1, Length: 77, dtype: float64\n",
      "3.3807194321939043\n"
     ]
    }
   ],
   "source": [
    "#找到和用户1相关的用户，且正相关\n",
    "similar_users = user_similar[1].drop([1]).dropna()\n",
    "similar_users = similar_users.where(similar_users>0).dropna()\n",
    "print(similar_users)\n",
    "#找到对物品2打分了的用户\n",
    "true_users = rating_matrix[2].dropna()\n",
    "fin_similar_users = true_users.index&similar_users.index\n",
    "fin_similar_users = similar_users.loc[list(fin_similar_users)]\n",
    "print(fin_similar_users)\n",
    "\n",
    "sum_up = 0\n",
    "sum_down = 0\n",
    "for sim_user_id,sim_value in fin_similar_users.items():\n",
    "    sim_user_rated_movies = rating_matrix.loc[sim_user_id][2]\n",
    "    sum_up += sim_user_rated_movies * sim_value\n",
    "    sum_down += sim_value\n",
    "    \n",
    "predict_rating = sum_up/sum_down\n",
    "print(predict_rating)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始加载数据...\n",
      "加载缓存中...\n",
      "从缓存中加载数据完毕...\n",
      "从缓存中加载用户相似度矩阵\n",
      "相似度矩阵处理完毕\n",
      "开始预测用户1对电影2的评分...\n",
      "预测出用户1对物品2的评分：3.38072\n",
      "3.38\n",
      "开始预测用户1对电影3的评分...\n",
      "预测出用户1对物品3的评分：3.13923\n",
      "3.14\n"
     ]
    }
   ],
   "source": [
    "def predict(uid,iid,rating_matrix,user_similar):\n",
    "    '''\n",
    "    预测uid用户给iid商品的评分\n",
    "    :param uid: 用户Id\n",
    "    :param iid: 商品Id\n",
    "    :param rating_matrix: 用户-物品评分矩阵\n",
    "    :param user_similar: 用户-用户相似度矩阵\n",
    "    :return: 预测的评分值\n",
    "    '''\n",
    "    print(f\"开始预测用户{uid}对电影{iid}的评分...\")\n",
    "    \n",
    "    #找到和用户uid正相关的用户\n",
    "    similar_users = user_similar[uid].drop([uid]).dropna()\n",
    "    similar_users = similar_users.where(similar_users>0).dropna()\n",
    "    if similar_users.empty is True:\n",
    "        raise Exception(\"用户{uid}没有相似用户\".format(uid=uid))\n",
    "    \n",
    "    #找到对物品iid打分了的用户\n",
    "    true_users = rating_matrix[iid].dropna()\n",
    "    \n",
    "    #从uid用户的近邻相似用户中筛选对iid用户有评分记录的用户\n",
    "    fin_similar_users = true_users.index&similar_users.index\n",
    "    fin_similar_users = similar_users.loc[list(fin_similar_users)]\n",
    "    \n",
    "    #通过相关用户预测用户uid对iid物品评分\n",
    "    sum_up = 0 #预测公式的分子部分\n",
    "    sum_down = 0 #预测公式的分母部分\n",
    "    for sim_user_id,sim_value in fin_similar_users.items():\n",
    "        #相似用户对iid的评分\n",
    "        sim_user_rated_movies = rating_matrix.loc[sim_user_id][iid]\n",
    "        sum_up += sim_user_rated_movies * sim_value\n",
    "        sum_down += sim_value\n",
    "        \n",
    "    predict_rating = sum_up/sum_down\n",
    "    print(f\"预测出用户{uid}对物品{iid}的评分：{predict_rating:.5f}\")\n",
    "    return round(predict_rating,2)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    rating_matrix = load_data(DATA_PATH)\n",
    "    user_similar = compute_pearson_similarity(rating_matrix,based='user')\n",
    "    print(predict(1,2,rating_matrix,user_similar))\n",
    "    print(predict(1,3,rating_matrix,user_similar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始加载数据...\n",
      "加载缓存中...\n",
      "从缓存中加载数据完毕...\n",
      "从缓存中加载用户相似度矩阵\n",
      "相似度矩阵处理完毕\n",
      "开始预测用户1对电影2的评分...\n",
      "预测出用户1对物品2的评分：3.38072\n",
      "(1, 2, 3.38)\n",
      "开始预测用户1对电影122882的评分...\n",
      "预测出用户1对物品122882的评分：3.73712\n",
      "(1, 122882, 3.74)\n",
      "开始预测用户1对电影5的评分...\n",
      "预测出用户1对物品5的评分：3.09120\n",
      "(1, 5, 3.09)\n",
      "开始预测用户1对电影122886的评分...\n",
      "预测出用户1对物品122886的评分：3.94512\n",
      "(1, 122886, 3.95)\n",
      "开始预测用户1对电影7的评分...\n",
      "预测出用户1对物品7的评分：3.22490\n",
      "(1, 7, 3.22)\n",
      "开始预测用户1对电影9的评分...\n",
      "预测出用户1对物品9的评分：2.58540\n",
      "(1, 9, 2.59)\n",
      "开始预测用户1对电影10的评分...\n",
      "预测出用户1对物品10的评分：3.41075\n",
      "(1, 10, 3.41)\n",
      "开始预测用户1对电影11的评分...\n",
      "预测出用户1对物品11的评分：3.68289\n",
      "(1, 11, 3.68)\n",
      "开始预测用户1对电影12的评分...\n",
      "预测出用户1对物品12的评分：2.49328\n",
      "(1, 12, 2.49)\n",
      "开始预测用户1对电影81932的评分...\n",
      "预测出用户1对物品81932的评分：3.76774\n",
      "(1, 81932, 3.77)\n",
      "开始预测用户1对电影14的评分...\n",
      "预测出用户1对物品14的评分：4.22911\n",
      "(1, 14, 4.23)\n",
      "开始预测用户1对电影15的评分...\n",
      "预测出用户1对物品15的评分：2.79375\n",
      "(1, 15, 2.79)\n",
      "开始预测用户1对电影16的评分...\n",
      "预测出用户1对物品16的评分：3.98431\n",
      "(1, 16, 3.98)\n",
      "开始预测用户1对电影17的评分...\n",
      "预测出用户1对物品17的评分：3.88149\n",
      "(1, 17, 3.88)\n",
      "开始预测用户1对电影18的评分...\n",
      "预测出用户1对物品18的评分：3.60734\n",
      "(1, 18, 3.61)\n",
      "开始预测用户1对电影19的评分...\n",
      "预测出用户1对物品19的评分：2.77037\n",
      "(1, 19, 2.77)\n",
      "开始预测用户1对电影20的评分...\n",
      "预测出用户1对物品20的评分：2.89641\n",
      "(1, 20, 2.9)\n",
      "开始预测用户1对电影21的评分...\n",
      "预测出用户1对物品21的评分：3.48757\n",
      "(1, 21, 3.49)\n",
      "开始预测用户1对电影22的评分...\n",
      "预测出用户1对物品22的评分：2.89508\n",
      "(1, 22, 2.9)\n",
      "开始预测用户1对电影23的评分...\n",
      "预测出用户1对物品23的评分：3.15681\n",
      "(1, 23, 3.16)\n",
      "开始预测用户1对电影24的评分...\n",
      "预测出用户1对物品24的评分：3.00238\n",
      "(1, 24, 3.0)\n",
      "开始预测用户1对电影25的评分...\n",
      "预测出用户1对物品25的评分：3.78110\n",
      "(1, 25, 3.78)\n",
      "开始预测用户1对电影26的评分...\n",
      "预测出用户1对物品26的评分：3.45840\n",
      "(1, 26, 3.46)\n",
      "开始预测用户1对电影57368的评分...\n",
      "预测出用户1对物品57368的评分：3.24651\n",
      "(1, 57368, 3.25)\n",
      "开始预测用户1对电影28的评分...\n",
      "预测出用户1对物品28的评分：4.38234\n",
      "(1, 28, 4.38)\n",
      "开始预测用户1对电影29的评分...\n",
      "预测出用户1对物品29的评分：4.18804\n",
      "(1, 29, 4.19)\n",
      "开始预测用户1对电影122904的评分...\n",
      "预测出用户1对物品122904的评分：3.99608\n",
      "(1, 122904, 4.0)\n",
      "开始预测用户1对电影31的评分...\n",
      "预测出用户1对物品31的评分：3.10464\n",
      "(1, 31, 3.1)\n",
      "开始预测用户1对电影32的评分...\n",
      "预测出用户1对物品32的评分：4.02149\n",
      "(1, 32, 4.02)\n",
      "开始预测用户1对电影122906的评分...\n",
      "预测出用户1对物品122906的评分：4.29098\n",
      "(1, 122906, 4.29)\n",
      "开始预测用户1对电影34的评分...\n",
      "预测出用户1对物品34的评分：3.62297\n",
      "(1, 34, 3.62)\n",
      "开始预测用户1对电影122912的评分...\n",
      "预测出用户1对物品122912的评分：3.61408\n",
      "(1, 122912, 3.61)\n",
      "开始预测用户1对电影36的评分...\n",
      "预测出用户1对物品36的评分：3.85436\n",
      "(1, 36, 3.85)\n",
      "开始预测用户1对电影8228的评分...\n",
      "预测出用户1对物品8228的评分：3.70437\n",
      "(1, 8228, 3.7)\n",
      "开始预测用户1对电影122916的评分...\n",
      "预测出用户1对物品122916的评分：3.94043\n",
      "(1, 122916, 3.94)\n",
      "开始预测用户1对电影39的评分...\n",
      "预测出用户1对物品39的评分：3.16330\n",
      "(1, 39, 3.16)\n",
      "开始预测用户1对电影122918的评分...\n",
      "预测出用户1对物品122918的评分：4.20625\n",
      "(1, 122918, 4.21)\n",
      "开始预测用户1对电影41的评分...\n",
      "预测出用户1对物品41的评分：3.56913\n",
      "(1, 41, 3.57)\n",
      "开始预测用户1对电影122920的评分...\n",
      "预测出用户1对物品122920的评分：3.56979\n",
      "(1, 122920, 3.57)\n",
      "开始预测用户1对电影122922的评分...\n",
      "预测出用户1对物品122922的评分：3.60917\n",
      "(1, 122922, 3.61)\n",
      "开始预测用户1对电影44的评分...\n",
      "预测出用户1对物品44的评分：2.33174\n",
      "(1, 44, 2.33)\n",
      "开始预测用户1对电影45的评分...\n",
      "预测出用户1对物品45的评分：3.38128\n",
      "(1, 45, 3.38)\n",
      "开始预测用户1对电影46的评分...\n",
      "预测出用户1对物品46的评分：2.62097\n",
      "(1, 46, 2.62)\n",
      "开始预测用户1对电影122924的评分...\n",
      "预测出用户1对物品122924的评分：3.24646\n",
      "(1, 122924, 3.25)\n",
      "开始预测用户1对电影48的评分...\n",
      "预测出用户1对物品48的评分：3.07192\n",
      "(1, 48, 3.07)\n",
      "开始预测用户1对电影122926的评分...\n",
      "预测出用户1对物品122926的评分：4.20248\n",
      "(1, 122926, 4.2)\n",
      "开始预测用户1对电影52的评分...\n",
      "预测出用户1对物品52的评分：3.72700\n",
      "(1, 52, 3.73)\n",
      "开始预测用户1对电影58的评分...\n",
      "预测出用户1对物品58的评分：4.49235\n",
      "(1, 58, 4.49)\n",
      "开始预测用户1对电影60的评分...\n",
      "预测出用户1对物品60的评分：2.86828\n",
      "(1, 60, 2.87)\n",
      "开始预测用户1对电影62的评分...\n",
      "预测出用户1对物品62的评分：3.81136\n",
      "(1, 62, 3.81)\n",
      "开始预测用户1对电影65的评分...\n",
      "预测出用户1对物品65的评分：2.39166\n",
      "(1, 65, 2.39)\n",
      "开始预测用户1对电影69的评分...\n",
      "预测出用户1对物品69的评分：3.69686\n",
      "(1, 69, 3.7)\n",
      "开始预测用户1对电影73的评分...\n",
      "预测出用户1对物品73的评分：3.67925\n",
      "(1, 73, 3.68)\n",
      "开始预测用户1对电影76的评分...\n",
      "预测出用户1对物品76的评分：2.96966\n",
      "(1, 76, 2.97)\n",
      "开始预测用户1对电影79的评分...\n",
      "预测出用户1对物品79的评分：2.27561\n",
      "(1, 79, 2.28)\n",
      "开始预测用户1对电影81的评分...\n",
      "预测出用户1对物品81的评分：3.14430\n",
      "(1, 81, 3.14)\n",
      "开始预测用户1对电影86的评分...\n",
      "预测出用户1对物品86的评分：3.64668\n",
      "(1, 86, 3.65)\n",
      "开始预测用户1对电影88的评分...\n",
      "预测出用户1对物品88的评分：3.09485\n",
      "(1, 88, 3.09)\n",
      "开始预测用户1对电影95的评分...\n",
      "预测出用户1对物品95的评分：2.67317\n",
      "(1, 95, 2.67)\n",
      "开始预测用户1对电影100的评分...\n",
      "预测出用户1对物品100的评分：2.41417\n",
      "(1, 100, 2.41)\n",
      "开始预测用户1对电影104的评分...\n",
      "预测出用户1对物品104的评分：3.50745\n",
      "(1, 104, 3.51)\n",
      "开始预测用户1对电影105的评分...\n",
      "预测出用户1对物品105的评分：3.35073\n",
      "(1, 105, 3.35)\n",
      "开始预测用户1对电影107的评分...\n",
      "预测出用户1对物品107的评分：3.10349\n",
      "(1, 107, 3.1)\n",
      "开始预测用户1对电影111的评分...\n",
      "预测出用户1对物品111的评分：3.98511\n",
      "(1, 111, 3.99)\n",
      "开始预测用户1对电影112的评分...\n",
      "预测出用户1对物品112的评分：3.47990\n",
      "(1, 112, 3.48)\n",
      "开始预测用户1对电影49272的评分...\n",
      "预测出用户1对物品49272的评分：3.83615\n",
      "(1, 49272, 3.84)\n",
      "开始预测用户1对电影139385的评分...\n",
      "预测出用户1对物品139385的评分：4.09582\n",
      "(1, 139385, 4.1)\n",
      "开始预测用户1对电影49274的评分...\n",
      "预测出用户1对物品49274的评分：3.08514\n",
      "(1, 49274, 3.09)\n",
      "开始预测用户1对电影122的评分...\n",
      "预测出用户1对物品122的评分：2.81646\n",
      "(1, 122, 2.82)\n",
      "开始预测用户1对电影125的评分...\n",
      "预测出用户1对物品125的评分：3.49921\n",
      "(1, 125, 3.5)\n",
      "开始预测用户1对电影49278的评分...\n",
      "预测出用户1对物品49278的评分：3.11851\n",
      "(1, 49278, 3.12)\n",
      "开始预测用户1对电影49286的评分...\n",
      "预测出用户1对物品49286的评分：3.14960\n",
      "(1, 49286, 3.15)\n",
      "开始预测用户1对电影135的评分...\n",
      "预测出用户1对物品135的评分：2.38569\n",
      "(1, 135, 2.39)\n",
      "开始预测用户1对电影140的评分...\n",
      "预测出用户1对物品140的评分：3.62182\n",
      "(1, 140, 3.62)\n",
      "开始预测用户1对电影141的评分...\n",
      "预测出用户1对物品141的评分：3.40046\n",
      "(1, 141, 3.4)\n",
      "开始预测用户1对电影144的评分...\n",
      "预测出用户1对物品144的评分：3.50307\n",
      "(1, 144, 3.5)\n",
      "开始预测用户1对电影145的评分...\n",
      "预测出用户1对物品145的评分：3.38620\n",
      "(1, 145, 3.39)\n",
      "开始预测用户1对电影147的评分...\n",
      "预测出用户1对物品147的评分：3.54310\n",
      "(1, 147, 3.54)\n",
      "开始预测用户1对电影150的评分...\n",
      "预测出用户1对物品150的评分：3.81256\n",
      "(1, 150, 3.81)\n",
      "开始预测用户1对电影153的评分...\n",
      "预测出用户1对物品153的评分：2.87531\n",
      "(1, 153, 2.88)\n",
      "开始预测用户1对电影154的评分...\n",
      "预测出用户1对物品154的评分：4.00592\n",
      "(1, 154, 4.01)\n",
      "开始预测用户1对电影158的评分...\n",
      "预测出用户1对物品158的评分：2.43721\n",
      "(1, 158, 2.44)\n",
      "开始预测用户1对电影159的评分...\n",
      "预测出用户1对物品159的评分：2.31297\n",
      "(1, 159, 2.31)\n",
      "开始预测用户1对电影160的评分...\n",
      "预测出用户1对物品160的评分：2.71746\n",
      "(1, 160, 2.72)\n",
      "开始预测用户1对电影161的评分...\n",
      "预测出用户1对物品161的评分：3.44194\n",
      "(1, 161, 3.44)\n",
      "开始预测用户1对电影162的评分...\n",
      "预测出用户1对物品162的评分：4.24213\n",
      "(1, 162, 4.24)\n",
      "开始预测用户1对电影164的评分...\n",
      "预测出用户1对物品164的评分：2.56666\n",
      "(1, 164, 2.57)\n",
      "开始预测用户1对电影165的评分...\n",
      "预测出用户1对物品165的评分：3.43946\n",
      "(1, 165, 3.44)\n",
      "开始预测用户1对电影168的评分...\n",
      "预测出用户1对物品168的评分：3.20128\n",
      "(1, 168, 3.2)\n",
      "开始预测用户1对电影8360的评分...\n",
      "预测出用户1对物品8360的评分：3.49763\n",
      "(1, 8360, 3.5)\n",
      "开始预测用户1对电影170的评分...\n",
      "预测出用户1对物品170的评分：3.12433\n",
      "(1, 170, 3.12)\n",
      "开始预测用户1对电影8361的评分...\n",
      "预测出用户1对物品8361的评分：3.00302\n",
      "(1, 8361, 3.0)\n",
      "开始预测用户1对电影172的评分...\n",
      "预测出用户1对物品172的评分：2.29483\n",
      "(1, 172, 2.29)\n",
      "开始预测用户1对电影173的评分...\n",
      "预测出用户1对物品173的评分：2.25523\n",
      "(1, 173, 2.26)\n",
      "开始预测用户1对电影8366的评分...\n",
      "预测出用户1对物品8366的评分：3.74039\n",
      "(1, 8366, 3.74)\n",
      "开始预测用户1对电影175的评分...\n",
      "预测出用户1对物品175的评分：3.99024\n",
      "(1, 175, 3.99)\n",
      "开始预测用户1对电影176的评分...\n",
      "预测出用户1对物品176的评分：4.30522\n",
      "(1, 176, 4.31)\n",
      "开始预测用户1对电影8368的评分...\n",
      "预测出用户1对物品8368的评分：4.00733\n",
      "(1, 8368, 4.01)\n",
      "开始预测用户1对电影8370的评分...\n",
      "预测出用户1对物品8370的评分：4.07322\n",
      "(1, 8370, 4.07)\n",
      "开始预测用户1对电影8371的评分...\n",
      "预测出用户1对物品8371的评分：2.82050\n",
      "(1, 8371, 2.82)\n",
      "开始预测用户1对电影180的评分...\n",
      "预测出用户1对物品180的评分：3.62204\n",
      "(1, 180, 3.62)\n",
      "开始预测用户1对电影181的评分...\n",
      "预测出用户1对物品181的评分：1.66595\n",
      "(1, 181, 1.67)\n",
      "开始预测用户1对电影8373的评分...\n",
      "预测出用户1对物品8373的评分：2.07524\n",
      "(1, 8373, 2.08)\n",
      "开始预测用户1对电影8376的评分...\n",
      "预测出用户1对物品8376的评分：3.53797\n",
      "(1, 8376, 3.54)\n",
      "开始预测用户1对电影185的评分...\n",
      "预测出用户1对物品185的评分：2.69662\n",
      "(1, 185, 2.7)\n",
      "开始预测用户1对电影186的评分...\n",
      "预测出用户1对物品186的评分：2.43233\n",
      "(1, 186, 2.43)\n",
      "开始预测用户1对电影188的评分...\n",
      "预测出用户1对物品188的评分：3.60933\n",
      "(1, 188, 3.61)\n",
      "开始预测用户1对电影193的评分...\n",
      "预测出用户1对物品193的评分：1.98117\n",
      "(1, 193, 1.98)\n",
      "开始预测用户1对电影194的评分...\n",
      "预测出用户1对物品194的评分：3.54966\n",
      "(1, 194, 3.55)\n",
      "开始预测用户1对电影196的评分...\n",
      "预测出用户1对物品196的评分：2.33332\n",
      "(1, 196, 2.33)\n",
      "开始预测用户1对电影198的评分...\n",
      "预测出用户1对物品198的评分：3.28874\n",
      "(1, 198, 3.29)\n",
      "开始预测用户1对电影106696的评分...\n",
      "预测出用户1对物品106696的评分：3.97079\n",
      "(1, 106696, 3.97)\n",
      "开始预测用户1对电影203的评分...\n",
      "预测出用户1对物品203的评分：3.11287\n",
      "(1, 203, 3.11)\n",
      "开始预测用户1对电影204的评分...\n",
      "预测出用户1对物品204的评分：2.02024\n",
      "(1, 204, 2.02)\n",
      "开始预测用户1对电影207的评分...\n",
      "预测出用户1对物品207的评分：2.97483\n",
      "(1, 207, 2.97)\n",
      "开始预测用户1对电影208的评分...\n",
      "预测出用户1对物品208的评分：2.73543\n",
      "(1, 208, 2.74)\n",
      "开始预测用户1对电影215的评分...\n",
      "预测出用户1对物品215的评分：4.01823\n",
      "(1, 215, 4.02)\n",
      "开始预测用户1对电影218的评分...\n",
      "预测出用户1对物品218的评分：3.26216\n",
      "(1, 218, 3.26)\n",
      "开始预测用户1对电影222的评分...\n",
      "预测出用户1对物品222的评分：3.90588\n",
      "(1, 222, 3.91)\n",
      "开始预测用户1对电影224的评分...\n",
      "预测出用户1对物品224的评分：3.74763\n",
      "(1, 224, 3.75)\n",
      "开始预测用户1对电影225的评分...\n",
      "预测出用户1对物品225的评分：3.45212\n",
      "(1, 225, 3.45)\n",
      "开始预测用户1对电影227的评分...\n",
      "预测出用户1对物品227的评分：2.53087\n",
      "(1, 227, 2.53)\n",
      "开始预测用户1对电影230的评分...\n",
      "预测出用户1对物品230的评分：3.10355\n",
      "(1, 230, 3.1)\n",
      "开始预测用户1对电影232的评分...\n",
      "预测出用户1对物品232的评分：3.43603\n",
      "(1, 232, 3.44)\n",
      "开始预测用户1对电影233的评分...\n",
      "预测出用户1对物品233的评分：3.57779\n",
      "(1, 233, 3.58)\n",
      "开始预测用户1对电影234的评分...\n",
      "预测出用户1对物品234的评分：2.68738\n",
      "(1, 234, 2.69)\n",
      "开始预测用户1对电影236的评分...\n",
      "预测出用户1对物品236的评分：3.16407\n",
      "(1, 236, 3.16)\n",
      "开始预测用户1对电影237的评分...\n",
      "预测出用户1对物品237的评分：2.50696\n",
      "(1, 237, 2.51)\n",
      "开始预测用户1对电影33004的评分...\n",
      "预测出用户1对物品33004的评分：3.38724\n",
      "(1, 33004, 3.39)\n",
      "开始预测用户1对电影239的评分...\n",
      "预测出用户1对物品239的评分：3.07068\n",
      "(1, 239, 3.07)\n",
      "开始预测用户1对电影246的评分...\n",
      "预测出用户1对物品246的评分：4.38492\n",
      "(1, 246, 4.38)\n",
      "开始预测用户1对电影247的评分...\n",
      "预测出用户1对物品247的评分：3.89161\n",
      "(1, 247, 3.89)\n",
      "开始预测用户1对电影248的评分...\n",
      "预测出用户1对物品248的评分：2.78624\n",
      "(1, 248, 2.79)\n",
      "开始预测用户1对电影249的评分...\n",
      "预测出用户1对物品249的评分：3.81269\n",
      "(1, 249, 3.81)\n",
      "开始预测用户1对电影252的评分...\n",
      "预测出用户1对物品252的评分：3.48883\n",
      "(1, 252, 3.49)\n",
      "开始预测用户1对电影253的评分...\n",
      "预测出用户1对物品253的评分：3.35982\n",
      "(1, 253, 3.36)\n",
      "开始预测用户1对电影256的评分...\n",
      "预测出用户1对物品256的评分：2.65804\n",
      "(1, 256, 2.66)\n",
      "开始预测用户1对电影257的评分...\n",
      "预测出用户1对物品257的评分：3.35508\n",
      "(1, 257, 3.36)\n",
      "开始预测用户1对电影261的评分...\n",
      "预测出用户1对物品261的评分：4.15819\n",
      "(1, 261, 4.16)\n",
      "开始预测用户1对电影262的评分...\n",
      "预测出用户1对物品262的评分：3.78895\n",
      "(1, 262, 3.79)\n",
      "开始预测用户1对电影265的评分...\n",
      "预测出用户1对物品265的评分：4.07157\n",
      "(1, 265, 4.07)\n",
      "开始预测用户1对电影266的评分...\n",
      "预测出用户1对物品266的评分：3.42511\n",
      "(1, 266, 3.43)\n",
      "开始预测用户1对电影267的评分...\n",
      "预测出用户1对物品267的评分：2.98461\n",
      "(1, 267, 2.98)\n",
      "开始预测用户1对电影272的评分...\n",
      "预测出用户1对物品272的评分：4.08323\n",
      "(1, 272, 4.08)\n",
      "开始预测用户1对电影273的评分...\n",
      "预测出用户1对物品273的评分：2.76681\n",
      "(1, 273, 2.77)\n",
      "开始预测用户1对电影8464的评分...\n",
      "预测出用户1对物品8464的评分：3.52529\n",
      "(1, 8464, 3.53)\n",
      "开始预测用户1对电影276的评分...\n",
      "预测出用户1对物品276的评分：3.13553\n",
      "(1, 276, 3.14)\n",
      "开始预测用户1对电影277的评分...\n",
      "预测出用户1对物品277的评分：3.41919\n",
      "(1, 277, 3.42)\n",
      "开始预测用户1对电影280的评分...\n",
      "预测出用户1对物品280的评分：4.54442\n",
      "(1, 280, 4.54)\n",
      "开始预测用户1对电影281的评分...\n",
      "预测出用户1对物品281的评分：4.32925\n",
      "(1, 281, 4.33)\n",
      "开始预测用户1对电影282的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品282的评分：3.39832\n",
      "(1, 282, 3.4)\n",
      "开始预测用户1对电影106782的评分...\n",
      "预测出用户1对物品106782的评分：3.83536\n",
      "(1, 106782, 3.84)\n",
      "开始预测用户1对电影288的评分...\n",
      "预测出用户1对物品288的评分：3.22725\n",
      "(1, 288, 3.23)\n",
      "开始预测用户1对电影290的评分...\n",
      "预测出用户1对物品290的评分：4.48585\n",
      "(1, 290, 4.49)\n",
      "开始预测用户1对电影292的评分...\n",
      "预测出用户1对物品292的评分：3.28771\n",
      "(1, 292, 3.29)\n",
      "开始预测用户1对电影293的评分...\n",
      "预测出用户1对物品293的评分：4.03188\n",
      "(1, 293, 4.03)\n",
      "开始预测用户1对电影90405的评分...\n",
      "预测出用户1对物品90405的评分：3.40650\n",
      "(1, 90405, 3.41)\n",
      "开始预测用户1对电影57640的评分...\n",
      "预测出用户1对物品57640的评分：3.81264\n",
      "(1, 57640, 3.81)\n",
      "开始预测用户1对电影300的评分...\n",
      "预测出用户1对物品300的评分：3.42562\n",
      "(1, 300, 3.43)\n",
      "开始预测用户1对电影303的评分...\n",
      "预测出用户1对物品303的评分：2.92248\n",
      "(1, 303, 2.92)\n",
      "开始预测用户1对电影306的评分...\n",
      "预测出用户1对物品306的评分：4.19822\n",
      "(1, 306, 4.2)\n",
      "开始预测用户1对电影307的评分...\n",
      "预测出用户1对物品307的评分：3.46646\n",
      "(1, 307, 3.47)\n",
      "开始预测用户1对电影308的评分...\n",
      "预测出用户1对物品308的评分：3.94199\n",
      "(1, 308, 3.94)\n",
      "开始预测用户1对电影314的评分...\n",
      "预测出用户1对物品314的评分：3.53638\n",
      "(1, 314, 3.54)\n",
      "开始预测用户1对电影315的评分...\n",
      "预测出用户1对物品315的评分：2.90159\n",
      "(1, 315, 2.9)\n",
      "开始预测用户1对电影317的评分...\n",
      "预测出用户1对物品317的评分：2.96409\n",
      "(1, 317, 2.96)\n",
      "开始预测用户1对电影318的评分...\n",
      "预测出用户1对物品318的评分：4.55078\n",
      "(1, 318, 4.55)\n",
      "开始预测用户1对电影319的评分...\n",
      "预测出用户1对物品319的评分：3.95722\n",
      "(1, 319, 3.96)\n",
      "开始预测用户1对电影41285的评分...\n",
      "预测出用户1对物品41285的评分：3.65598\n",
      "(1, 41285, 3.66)\n",
      "开始预测用户1对电影57669的评分...\n",
      "预测出用户1对物品57669的评分：4.22443\n",
      "(1, 57669, 4.22)\n",
      "开始预测用户1对电影327的评分...\n",
      "预测出用户1对物品327的评分：2.44535\n",
      "(1, 327, 2.45)\n",
      "开始预测用户1对电影329的评分...\n",
      "预测出用户1对物品329的评分：3.29800\n",
      "(1, 329, 3.3)\n",
      "开始预测用户1对电影332的评分...\n",
      "预测出用户1对物品332的评分：2.88957\n",
      "(1, 332, 2.89)\n",
      "开始预测用户1对电影8528的评分...\n",
      "预测出用户1对物品8528的评分：3.39148\n",
      "(1, 8528, 3.39)\n",
      "开始预测用户1对电影337的评分...\n",
      "预测出用户1对物品337的评分：3.73449\n",
      "(1, 337, 3.73)\n",
      "开始预测用户1对电影338的评分...\n",
      "预测出用户1对物品338的评分：2.35658\n",
      "(1, 338, 2.36)\n",
      "开始预测用户1对电影339的评分...\n",
      "预测出用户1对物品339的评分：3.37188\n",
      "(1, 339, 3.37)\n",
      "开始预测用户1对电影8529的评分...\n",
      "预测出用户1对物品8529的评分：3.27438\n",
      "(1, 8529, 3.27)\n",
      "开始预测用户1对电影8533的评分...\n",
      "预测出用户1对物品8533的评分：3.78037\n",
      "(1, 8533, 3.78)\n",
      "开始预测用户1对电影342的评分...\n",
      "预测出用户1对物品342的评分：3.43483\n",
      "(1, 342, 3.43)\n",
      "开始预测用户1对电影164179的评分...\n",
      "预测出用户1对物品164179的评分：3.84104\n",
      "(1, 164179, 3.84)\n",
      "开始预测用户1对电影344的评分...\n",
      "预测出用户1对物品344的评分：2.99304\n",
      "(1, 344, 2.99)\n",
      "开始预测用户1对电影345的评分...\n",
      "预测出用户1对物品345的评分：3.61859\n",
      "(1, 345, 3.62)\n",
      "开始预测用户1对电影348的评分...\n",
      "预测出用户1对物品348的评分：3.64137\n",
      "(1, 348, 3.64)\n",
      "开始预测用户1对电影350的评分...\n",
      "预测出用户1对物品350的评分：3.07097\n",
      "(1, 350, 3.07)\n",
      "开始预测用户1对电影351的评分...\n",
      "预测出用户1对物品351的评分：3.21882\n",
      "(1, 351, 3.22)\n",
      "开始预测用户1对电影353的评分...\n",
      "预测出用户1对物品353的评分：3.90380\n",
      "(1, 353, 3.9)\n",
      "开始预测用户1对电影355的评分...\n",
      "预测出用户1对物品355的评分：1.98519\n",
      "(1, 355, 1.99)\n",
      "开始预测用户1对电影357的评分...\n",
      "预测出用户1对物品357的评分：3.55351\n",
      "(1, 357, 3.55)\n",
      "开始预测用户1对电影361的评分...\n",
      "预测出用户1对物品361的评分：2.83158\n",
      "(1, 361, 2.83)\n",
      "开始预测用户1对电影364的评分...\n",
      "预测出用户1对物品364的评分：3.97517\n",
      "(1, 364, 3.98)\n",
      "开始预测用户1对电影366的评分...\n",
      "预测出用户1对物品366的评分：2.20172\n",
      "(1, 366, 2.2)\n",
      "开始预测用户1对电影368的评分...\n",
      "预测出用户1对物品368的评分：3.53399\n",
      "(1, 368, 3.53)\n",
      "开始预测用户1对电影370的评分...\n",
      "预测出用户1对物品370的评分：3.04002\n",
      "(1, 370, 3.04)\n",
      "开始预测用户1对电影371的评分...\n",
      "预测出用户1对物品371的评分：3.17015\n",
      "(1, 371, 3.17)\n",
      "开始预测用户1对电影372的评分...\n",
      "预测出用户1对物品372的评分：2.73537\n",
      "(1, 372, 2.74)\n",
      "开始预测用户1对电影373的评分...\n",
      "预测出用户1对物品373的评分：3.49781\n",
      "(1, 373, 3.5)\n",
      "开始预测用户1对电影374的评分...\n",
      "预测出用户1对物品374的评分：1.65998\n",
      "(1, 374, 1.66)\n",
      "开始预测用户1对电影376的评分...\n",
      "预测出用户1对物品376的评分：3.27789\n",
      "(1, 376, 3.28)\n",
      "开始预测用户1对电影377的评分...\n",
      "预测出用户1对物品377的评分：3.28610\n",
      "(1, 377, 3.29)\n",
      "开始预测用户1对电影49530的评分...\n",
      "预测出用户1对物品49530的评分：3.70290\n",
      "(1, 49530, 3.7)\n",
      "开始预测用户1对电影379的评分...\n",
      "预测出用户1对物品379的评分：2.25101\n",
      "(1, 379, 2.25)\n",
      "开始预测用户1对电影380的评分...\n",
      "预测出用户1对物品380的评分：3.49676\n",
      "(1, 380, 3.5)\n",
      "开始预测用户1对电影381的评分...\n",
      "预测出用户1对物品381的评分：4.00671\n",
      "(1, 381, 4.01)\n",
      "开始预测用户1对电影382的评分...\n",
      "预测出用户1对物品382的评分：2.98725\n",
      "(1, 382, 2.99)\n",
      "开始预测用户1对电影383的评分...\n",
      "预测出用户1对物品383的评分：3.19387\n",
      "(1, 383, 3.19)\n",
      "开始预测用户1对电影139644的评分...\n",
      "预测出用户1对物品139644的评分：3.81224\n",
      "(1, 139644, 3.81)\n",
      "开始预测用户1对电影33162的评分...\n",
      "预测出用户1对物品33162的评分：3.14721\n",
      "(1, 33162, 3.15)\n",
      "开始预测用户1对电影33166的评分...\n",
      "预测出用户1对物品33166的评分：3.94755\n",
      "(1, 33166, 3.95)\n",
      "开始预测用户1对电影405的评分...\n",
      "预测出用户1对物品405的评分：2.60046\n",
      "(1, 405, 2.6)\n",
      "开始预测用户1对电影410的评分...\n",
      "预测出用户1对物品410的评分：3.03895\n",
      "(1, 410, 3.04)\n",
      "开始预测用户1对电影412的评分...\n",
      "预测出用户1对物品412的评分：3.41383\n",
      "(1, 412, 3.41)\n",
      "开始预测用户1对电影413的评分...\n",
      "预测出用户1对物品413的评分：2.74681\n",
      "(1, 413, 2.75)\n",
      "开始预测用户1对电影415的评分...\n",
      "预测出用户1对物品415的评分：2.25259\n",
      "(1, 415, 2.25)\n",
      "开始预测用户1对电影417的评分...\n",
      "预测出用户1对物品417的评分：3.84682\n",
      "(1, 417, 3.85)\n",
      "开始预测用户1对电影419的评分...\n",
      "预测出用户1对物品419的评分：2.97745\n",
      "(1, 419, 2.98)\n",
      "开始预测用户1对电影420的评分...\n",
      "预测出用户1对物品420的评分：2.57032\n",
      "(1, 420, 2.57)\n",
      "开始预测用户1对电影421的评分...\n",
      "预测出用户1对物品421的评分：3.35065\n",
      "(1, 421, 3.35)\n",
      "开始预测用户1对电影106916的评分...\n",
      "预测出用户1对物品106916的评分：3.72043\n",
      "(1, 106916, 3.72)\n",
      "开始预测用户1对电影106918的评分...\n",
      "预测出用户1对物品106918的评分：4.25911\n",
      "(1, 106918, 4.26)\n",
      "开始预测用户1对电影106920的评分...\n",
      "预测出用户1对物品106920的评分：3.94508\n",
      "(1, 106920, 3.95)\n",
      "开始预测用户1对电影427的评分...\n",
      "预测出用户1对物品427的评分：2.77567\n",
      "(1, 427, 2.78)\n",
      "开始预测用户1对电影428的评分...\n",
      "预测出用户1对物品428的评分：3.79022\n",
      "(1, 428, 3.79)\n",
      "开始预测用户1对电影8622的评分...\n",
      "预测出用户1对物品8622的评分：3.63281\n",
      "(1, 8622, 3.63)\n",
      "开始预测用户1对电影431的评分...\n",
      "预测出用户1对物品431的评分：3.62446\n",
      "(1, 431, 3.62)\n",
      "开始预测用户1对电影432的评分...\n",
      "预测出用户1对物品432的评分：2.31212\n",
      "(1, 432, 2.31)\n",
      "开始预测用户1对电影8623的评分...\n",
      "预测出用户1对物品8623的评分：3.19297\n",
      "(1, 8623, 3.19)\n",
      "开始预测用户1对电影434的评分...\n",
      "预测出用户1对物品434的评分：2.85310\n",
      "(1, 434, 2.85)\n",
      "开始预测用户1对电影435的评分...\n",
      "预测出用户1对物品435的评分：2.15691\n",
      "(1, 435, 2.16)\n",
      "开始预测用户1对电影440的评分...\n",
      "预测出用户1对物品440的评分：3.41479\n",
      "(1, 440, 3.41)\n",
      "开始预测用户1对电影442的评分...\n",
      "预测出用户1对物品442的评分：2.78448\n",
      "(1, 442, 2.78)\n",
      "开始预测用户1对电影8636的评分...\n",
      "预测出用户1对物品8636的评分：3.81239\n",
      "(1, 8636, 3.81)\n",
      "开始预测用户1对电影445的评分...\n",
      "预测出用户1对物品445的评分：3.03572\n",
      "(1, 445, 3.04)\n",
      "开始预测用户1对电影8638的评分...\n",
      "预测出用户1对物品8638的评分：3.29537\n",
      "(1, 8638, 3.3)\n",
      "开始预测用户1对电影8640的评分...\n",
      "预测出用户1对物品8640的评分：2.36348\n",
      "(1, 8640, 2.36)\n",
      "开始预测用户1对电影8641的评分...\n",
      "预测出用户1对物品8641的评分：3.79114\n",
      "(1, 8641, 3.79)\n",
      "开始预测用户1对电影8644的评分...\n",
      "预测出用户1对物品8644的评分：3.35128\n",
      "(1, 8644, 3.35)\n",
      "开始预测用户1对电影454的评分...\n",
      "预测出用户1对物品454的评分：3.47339\n",
      "(1, 454, 3.47)\n",
      "开始预测用户1对电影455的评分...\n",
      "预测出用户1对物品455的评分：2.40433\n",
      "(1, 455, 2.4)\n",
      "开始预测用户1对电影115149的评分...\n",
      "预测出用户1对物品115149的评分：3.90627\n",
      "(1, 115149, 3.91)\n",
      "开始预测用户1对电影466的评分...\n",
      "预测出用户1对物品466的评分：2.73647\n",
      "(1, 466, 2.74)\n",
      "开始预测用户1对电影468的评分...\n",
      "预测出用户1对物品468的评分：3.11714\n",
      "(1, 468, 3.12)\n",
      "开始预测用户1对电影471的评分...\n",
      "预测出用户1对物品471的评分：3.57628\n",
      "(1, 471, 3.58)\n",
      "开始预测用户1对电影8665的评分...\n",
      "预测出用户1对物品8665的评分：3.58791\n",
      "(1, 8665, 3.59)\n",
      "开始预测用户1对电影474的评分...\n",
      "预测出用户1对物品474的评分：3.67003\n",
      "(1, 474, 3.67)\n",
      "开始预测用户1对电影475的评分...\n",
      "预测出用户1对物品475的评分：4.27537\n",
      "(1, 475, 4.28)\n",
      "开始预测用户1对电影477的评分...\n",
      "预测出用户1对物品477的评分：3.49734\n",
      "(1, 477, 3.5)\n",
      "开始预测用户1对电影481的评分...\n",
      "预测出用户1对物品481的评分：2.99560\n",
      "(1, 481, 3.0)\n",
      "开始预测用户1对电影485的评分...\n",
      "预测出用户1对物品485的评分：3.03932\n",
      "(1, 485, 3.04)\n",
      "开始预测用户1对电影489的评分...\n",
      "预测出用户1对物品489的评分：2.64166\n",
      "(1, 489, 2.64)\n",
      "开始预测用户1对电影490的评分...\n",
      "预测出用户1对物品490的评分：2.94087\n",
      "(1, 490, 2.94)\n",
      "开始预测用户1对电影491的评分...\n",
      "预测出用户1对物品491的评分：3.59077\n",
      "(1, 491, 3.59)\n",
      "开始预测用户1对电影492的评分...\n",
      "预测出用户1对物品492的评分：3.50621\n",
      "(1, 492, 3.51)\n",
      "开始预测用户1对电影493的评分...\n",
      "预测出用户1对物品493的评分：3.95280\n",
      "(1, 493, 3.95)\n",
      "开始预测用户1对电影494的评分...\n",
      "预测出用户1对物品494的评分：3.12942\n",
      "(1, 494, 3.13)\n",
      "开始预测用户1对电影497的评分...\n",
      "预测出用户1对物品497的评分：3.84767\n",
      "(1, 497, 3.85)\n",
      "开始预测用户1对电影49649的评分...\n",
      "预测出用户1对物品49649的评分：1.76072\n",
      "(1, 49649, 1.76)\n",
      "开始预测用户1对电影49651的评分...\n",
      "预测出用户1对物品49651的评分：3.35041\n",
      "(1, 49651, 3.35)\n",
      "开始预测用户1对电影502的评分...\n",
      "预测出用户1对物品502的评分：2.17630\n",
      "(1, 502, 2.18)\n",
      "开始预测用户1对电影98809的评分...\n",
      "预测出用户1对物品98809的评分：3.77518\n",
      "(1, 98809, 3.78)\n",
      "开始预测用户1对电影507的评分...\n",
      "预测出用户1对物品507的评分：3.08298\n",
      "(1, 507, 3.08)\n",
      "开始预测用户1对电影508的评分...\n",
      "预测出用户1对物品508的评分：3.61547\n",
      "(1, 508, 3.62)\n",
      "开始预测用户1对电影509的评分...\n",
      "预测出用户1对物品509的评分：3.55022\n",
      "(1, 509, 3.55)\n",
      "开始预测用户1对电影514的评分...\n",
      "预测出用户1对物品514的评分：3.27213\n",
      "(1, 514, 3.27)\n",
      "开始预测用户1对电影515的评分...\n",
      "预测出用户1对物品515的评分：3.79755\n",
      "(1, 515, 3.8)\n",
      "开始预测用户1对电影516的评分...\n",
      "预测出用户1对物品516的评分：3.14590\n",
      "(1, 516, 3.15)\n",
      "开始预测用户1对电影519的评分...\n",
      "预测出用户1对物品519的评分：2.00540\n",
      "(1, 519, 2.01)\n",
      "开始预测用户1对电影520的评分...\n",
      "预测出用户1对物品520的评分：3.18817\n",
      "(1, 520, 3.19)\n",
      "开始预测用户1对电影115210的评分...\n",
      "预测出用户1对物品115210的评分：3.74925\n",
      "(1, 115210, 3.75)\n",
      "开始预测用户1对电影524的评分...\n",
      "预测出用户1对物品524的评分：3.46122\n",
      "(1, 524, 3.46)\n",
      "开始预测用户1对电影529的评分...\n",
      "预测出用户1对物品529的评分：3.80620\n",
      "(1, 529, 3.81)\n",
      "开始预测用户1对电影531的评分...\n",
      "预测出用户1对物品531的评分：3.41927\n",
      "(1, 531, 3.42)\n",
      "开始预测用户1对电影532的评分...\n",
      "预测出用户1对物品532的评分：2.97564\n",
      "(1, 532, 2.98)\n",
      "开始预测用户1对电影533的评分...\n",
      "预测出用户1对物品533的评分：2.68131\n",
      "(1, 533, 2.68)\n",
      "开始预测用户1对电影534的评分...\n",
      "预测出用户1对物品534的评分：3.93327\n",
      "(1, 534, 3.93)\n",
      "开始预测用户1对电影535的评分...\n",
      "预测出用户1对物品535的评分：3.03273\n",
      "(1, 535, 3.03)\n",
      "开始预测用户1对电影537的评分...\n",
      "预测出用户1对物品537的评分：2.97729\n",
      "(1, 537, 2.98)\n",
      "开始预测用户1对电影538的评分...\n",
      "预测出用户1对物品538的评分：3.83325\n",
      "(1, 538, 3.83)\n",
      "开始预测用户1对电影539的评分...\n",
      "预测出用户1对物品539的评分：3.38364\n",
      "(1, 539, 3.38)\n",
      "开始预测用户1对电影82459的评分...\n",
      "预测出用户1对物品82459的评分：3.65597\n",
      "(1, 82459, 3.66)\n",
      "开始预测用户1对电影540的评分...\n",
      "预测出用户1对物品540的评分：2.28803\n",
      "(1, 540, 2.29)\n",
      "开始预测用户1对电影541的评分...\n",
      "预测出用户1对物品541的评分：4.16658\n",
      "(1, 541, 4.17)\n",
      "开始预测用户1对电影82461的评分...\n",
      "预测出用户1对物品82461的评分：3.16685\n",
      "(1, 82461, 3.17)\n",
      "开始预测用户1对电影542的评分...\n",
      "预测出用户1对物品542的评分：2.18717\n",
      "(1, 542, 2.19)\n",
      "开始预测用户1对电影546的评分...\n",
      "预测出用户1对物品546的评分：1.96290\n",
      "(1, 546, 1.96)\n",
      "开始预测用户1对电影551的评分...\n",
      "预测出用户1对物品551的评分：3.60375\n",
      "(1, 551, 3.6)\n",
      "开始预测用户1对电影555的评分...\n",
      "预测出用户1对物品555的评分：3.85343\n",
      "(1, 555, 3.85)\n",
      "开始预测用户1对电影66097的评分...\n",
      "预测出用户1对物品66097的评分：3.67857\n",
      "(1, 66097, 3.68)\n",
      "开始预测用户1对电影562的评分...\n",
      "预测出用户1对物品562的评分：3.54889\n",
      "(1, 562, 3.55)\n",
      "开始预测用户1对电影575的评分...\n",
      "预测出用户1对物品575的评分：2.61624\n",
      "(1, 575, 2.62)\n",
      "开始预测用户1对电影585的评分...\n",
      "预测出用户1对物品585的评分：2.63462\n",
      "(1, 585, 2.63)\n",
      "开始预测用户1对电影586的评分...\n",
      "预测出用户1对物品586的评分：3.03284\n",
      "(1, 586, 3.03)\n",
      "开始预测用户1对电影587的评分...\n",
      "预测出用户1对物品587的评分：3.36147\n",
      "(1, 587, 3.36)\n",
      "开始预测用户1对电影588的评分...\n",
      "预测出用户1对物品588的评分：3.76884\n",
      "(1, 588, 3.77)\n",
      "开始预测用户1对电影589的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品589的评分：3.97191\n",
      "(1, 589, 3.97)\n",
      "开始预测用户1对电影8781的评分...\n",
      "预测出用户1对物品8781的评分：2.98332\n",
      "(1, 8781, 2.98)\n",
      "开始预测用户1对电影8783的评分...\n",
      "预测出用户1对物品8783的评分：3.59511\n",
      "(1, 8783, 3.6)\n",
      "开始预测用户1对电影8784的评分...\n",
      "预测出用户1对物品8784的评分：3.89181\n",
      "(1, 8784, 3.89)\n",
      "开始预测用户1对电影594的评分...\n",
      "预测出用户1对物品594的评分：3.81204\n",
      "(1, 594, 3.81)\n",
      "开始预测用户1对电影595的评分...\n",
      "预测出用户1对物品595的评分：3.67268\n",
      "(1, 595, 3.67)\n",
      "开始预测用户1对电影597的评分...\n",
      "预测出用户1对物品597的评分：3.49614\n",
      "(1, 597, 3.5)\n",
      "开始预测用户1对电影599的评分...\n",
      "预测出用户1对物品599的评分：3.99032\n",
      "(1, 599, 3.99)\n",
      "开始预测用户1对电影8798的评分...\n",
      "预测出用户1对物品8798的评分：3.76707\n",
      "(1, 8798, 3.77)\n",
      "开始预测用户1对电影41566的评分...\n",
      "预测出用户1对物品41566的评分：3.17802\n",
      "(1, 41566, 3.18)\n",
      "开始预测用户1对电影609的评分...\n",
      "预测出用户1对物品609的评分：3.48227\n",
      "(1, 609, 3.48)\n",
      "开始预测用户1对电影610的评分...\n",
      "预测出用户1对物品610的评分：3.17151\n",
      "(1, 610, 3.17)\n",
      "开始预测用户1对电影41569的评分...\n",
      "预测出用户1对物品41569的评分：3.47006\n",
      "(1, 41569, 3.47)\n",
      "开始预测用户1对电影41571的评分...\n",
      "预测出用户1对物品41571的评分：3.80796\n",
      "(1, 41571, 3.81)\n",
      "开始预测用户1对电影8807的评分...\n",
      "预测出用户1对物品8807的评分：3.52291\n",
      "(1, 8807, 3.52)\n",
      "开始预测用户1对电影616的评分...\n",
      "预测出用户1对物品616的评分：3.53660\n",
      "(1, 616, 3.54)\n",
      "开始预测用户1对电影8810的评分...\n",
      "预测出用户1对物品8810的评分：2.64653\n",
      "(1, 8810, 2.65)\n",
      "开始预测用户1对电影628的评分...\n",
      "预测出用户1对物品628的评分：3.43224\n",
      "(1, 628, 3.43)\n",
      "开始预测用户1对电影631的评分...\n",
      "预测出用户1对物品631的评分：3.14062\n",
      "(1, 631, 3.14)\n",
      "开始预测用户1对电影90746的评分...\n",
      "预测出用户1对物品90746的评分：3.58326\n",
      "(1, 90746, 3.58)\n",
      "开始预测用户1对电影637的评分...\n",
      "预测出用户1对物品637的评分：2.88166\n",
      "(1, 637, 2.88)\n",
      "开始预测用户1对电影640的评分...\n",
      "预测出用户1对物品640的评分：2.66136\n",
      "(1, 640, 2.66)\n",
      "开始预测用户1对电影647的评分...\n",
      "预测出用户1对物品647的评分：3.14585\n",
      "(1, 647, 3.15)\n",
      "开始预测用户1对电影653的评分...\n",
      "预测出用户1对物品653的评分：2.98082\n",
      "(1, 653, 2.98)\n",
      "开始预测用户1对电影98961的评分...\n",
      "预测出用户1对物品98961的评分：4.12875\n",
      "(1, 98961, 4.13)\n",
      "开始预测用户1对电影663的评分...\n",
      "预测出用户1对物品663的评分：3.52727\n",
      "(1, 663, 3.53)\n",
      "开始预测用户1对电影66203的评分...\n",
      "预测出用户1对物品66203的评分：2.82036\n",
      "(1, 66203, 2.82)\n",
      "开始预测用户1对电影8861的评分...\n",
      "预测出用户1对物品8861的评分：2.98422\n",
      "(1, 8861, 2.98)\n",
      "开始预测用户1对电影671的评分...\n",
      "预测出用户1对物品671的评分：3.39585\n",
      "(1, 671, 3.4)\n",
      "开始预测用户1对电影8865的评分...\n",
      "预测出用户1对物品8865的评分：2.49217\n",
      "(1, 8865, 2.49)\n",
      "开始预测用户1对电影8873的评分...\n",
      "预测出用户1对物品8873的评分：4.01249\n",
      "(1, 8873, 4.01)\n",
      "开始预测用户1对电影8874的评分...\n",
      "预测出用户1对物品8874的评分：4.05739\n",
      "(1, 8874, 4.06)\n",
      "开始预测用户1对电影58025的评分...\n",
      "预测出用户1对物品58025的评分：2.41044\n",
      "(1, 58025, 2.41)\n",
      "开始预测用户1对电影694的评分...\n",
      "预测出用户1对物品694的评分：2.59586\n",
      "(1, 694, 2.6)\n",
      "开始预测用户1对电影58047的评分...\n",
      "预测出用户1对物品58047的评分：3.66113\n",
      "(1, 58047, 3.66)\n",
      "开始预测用户1对电影99007的评分...\n",
      "预测出用户1对物品99007的评分：3.73059\n",
      "(1, 99007, 3.73)\n",
      "开始预测用户1对电影707的评分...\n",
      "预测出用户1对物品707的评分：2.87122\n",
      "(1, 707, 2.87)\n",
      "开始预测用户1对电影708的评分...\n",
      "预测出用户1对物品708的评分：3.49068\n",
      "(1, 708, 3.49)\n",
      "开始预测用户1对电影709的评分...\n",
      "预测出用户1对物品709的评分：3.02576\n",
      "(1, 709, 3.03)\n",
      "开始预测用户1对电影714的评分...\n",
      "预测出用户1对物品714的评分：4.71691\n",
      "(1, 714, 4.72)\n",
      "开始预测用户1对电影8907的评分...\n",
      "预测出用户1对物品8907的评分：2.20552\n",
      "(1, 8907, 2.21)\n",
      "开始预测用户1对电影8910的评分...\n",
      "预测出用户1对物品8910的评分：3.57291\n",
      "(1, 8910, 3.57)\n",
      "开始预测用户1对电影719的评分...\n",
      "预测出用户1对物品719的评分：2.76692\n",
      "(1, 719, 2.77)\n",
      "开始预测用户1对电影720的评分...\n",
      "预测出用户1对物品720的评分：4.43114\n",
      "(1, 720, 4.43)\n",
      "开始预测用户1对电影8914的评分...\n",
      "预测出用户1对物品8914的评分：3.94864\n",
      "(1, 8914, 3.95)\n",
      "开始预测用户1对电影724的评分...\n",
      "预测出用户1对物品724的评分：2.96496\n",
      "(1, 724, 2.96)\n",
      "开始预测用户1对电影8917的评分...\n",
      "预测出用户1对物品8917的评分：3.83976\n",
      "(1, 8917, 3.84)\n",
      "开始预测用户1对电影33493的评分...\n",
      "预测出用户1对物品33493的评分：3.45375\n",
      "(1, 33493, 3.45)\n",
      "开始预测用户1对电影74458的评分...\n",
      "预测出用户1对物品74458的评分：4.01824\n",
      "(1, 74458, 4.02)\n",
      "开始预测用户1对电影737的评分...\n",
      "预测出用户1对物品737的评分：2.61471\n",
      "(1, 737, 2.61)\n",
      "开始预测用户1对电影741的评分...\n",
      "预测出用户1对物品741的评分：4.41417\n",
      "(1, 741, 4.41)\n",
      "开始预测用户1对电影742的评分...\n",
      "预测出用户1对物品742的评分：2.66720\n",
      "(1, 742, 2.67)\n",
      "开始预测用户1对电影743的评分...\n",
      "预测出用户1对物品743的评分：2.31643\n",
      "(1, 743, 2.32)\n",
      "开始预测用户1对电影745的评分...\n",
      "预测出用户1对物品745的评分：3.95206\n",
      "(1, 745, 3.95)\n",
      "开始预测用户1对电影748的评分...\n",
      "预测出用户1对物品748的评分：2.75090\n",
      "(1, 748, 2.75)\n",
      "开始预测用户1对电影750的评分...\n",
      "预测出用户1对物品750的评分：4.34218\n",
      "(1, 750, 4.34)\n",
      "开始预测用户1对电影90866的评分...\n",
      "预测出用户1对物品90866的评分：3.97157\n",
      "(1, 90866, 3.97)\n",
      "开始预测用户1对电影8949的评分...\n",
      "预测出用户1对物品8949的评分：3.76160\n",
      "(1, 8949, 3.76)\n",
      "开始预测用户1对电影8950的评分...\n",
      "预测出用户1对物品8950的评分：4.02937\n",
      "(1, 8950, 4.03)\n",
      "开始预测用户1对电影761的评分...\n",
      "预测出用户1对物品761的评分：3.00518\n",
      "(1, 761, 3.01)\n",
      "开始预测用户1对电影762的评分...\n",
      "预测出用户1对物品762的评分：2.26317\n",
      "(1, 762, 2.26)\n",
      "开始预测用户1对电影765的评分...\n",
      "预测出用户1对物品765的评分：3.07597\n",
      "(1, 765, 3.08)\n",
      "开始预测用户1对电影8957的评分...\n",
      "预测出用户1对物品8957的评分：3.29218\n",
      "(1, 8957, 3.29)\n",
      "开始预测用户1对电影8958的评分...\n",
      "预测出用户1对物品8958的评分：3.83742\n",
      "(1, 8958, 3.84)\n",
      "开始预测用户1对电影8961的评分...\n",
      "预测出用户1对物品8961的评分：3.82843\n",
      "(1, 8961, 3.83)\n",
      "开始预测用户1对电影8965的评分...\n",
      "预测出用户1对物品8965的评分：3.07308\n",
      "(1, 8965, 3.07)\n",
      "开始预测用户1对电影8969的评分...\n",
      "预测出用户1对物品8969的评分：2.91251\n",
      "(1, 8969, 2.91)\n",
      "开始预测用户1对电影778的评分...\n",
      "预测出用户1对物品778的评分：4.14223\n",
      "(1, 778, 4.14)\n",
      "开始预测用户1对电影8970的评分...\n",
      "预测出用户1对物品8970的评分：3.96836\n",
      "(1, 8970, 3.97)\n",
      "开始预测用户1对电影8972的评分...\n",
      "预测出用户1对物品8972的评分：3.03182\n",
      "(1, 8972, 3.03)\n",
      "开始预测用户1对电影783的评分...\n",
      "预测出用户1对物品783的评分：3.34812\n",
      "(1, 783, 3.35)\n",
      "开始预测用户1对电影784的评分...\n",
      "预测出用户1对物品784的评分：2.76151\n",
      "(1, 784, 2.76)\n",
      "开始预测用户1对电影785的评分...\n",
      "预测出用户1对物品785的评分：3.50642\n",
      "(1, 785, 3.51)\n",
      "开始预测用户1对电影786的评分...\n",
      "预测出用户1对物品786的评分：2.83052\n",
      "(1, 786, 2.83)\n",
      "开始预测用户1对电影788的评分...\n",
      "预测出用户1对物品788的评分：2.49925\n",
      "(1, 788, 2.5)\n",
      "开始预测用户1对电影8981的评分...\n",
      "预测出用户1对物品8981的评分：3.49971\n",
      "(1, 8981, 3.5)\n",
      "开始预测用户1对电影8983的评分...\n",
      "预测出用户1对物品8983的评分：3.50569\n",
      "(1, 8983, 3.51)\n",
      "开始预测用户1对电影8984的评分...\n",
      "预测出用户1对物品8984的评分：3.18584\n",
      "(1, 8984, 3.19)\n",
      "开始预测用户1对电影8985的评分...\n",
      "预测出用户1对物品8985的评分：2.01992\n",
      "(1, 8985, 2.02)\n",
      "开始预测用户1对电影798的评分...\n",
      "预测出用户1对物品798的评分：2.20247\n",
      "(1, 798, 2.2)\n",
      "开始预测用户1对电影799的评分...\n",
      "预测出用户1对物品799的评分：3.29541\n",
      "(1, 799, 3.3)\n",
      "开始预测用户1对电影800的评分...\n",
      "预测出用户1对物品800的评分：4.45040\n",
      "(1, 800, 4.45)\n",
      "开始预测用户1对电影801的评分...\n",
      "预测出用户1对物品801的评分：3.10131\n",
      "(1, 801, 3.1)\n",
      "开始预测用户1对电影802的评分...\n",
      "预测出用户1对物品802的评分：3.23510\n",
      "(1, 802, 3.24)\n",
      "开始预测用户1对电影805的评分...\n",
      "预测出用户1对物品805的评分：3.62436\n",
      "(1, 805, 3.62)\n",
      "开始预测用户1对电影99112的评分...\n",
      "预测出用户1对物品99112的评分：3.32649\n",
      "(1, 99112, 3.33)\n",
      "开始预测用户1对电影810的评分...\n",
      "预测出用户1对物品810的评分：1.63128\n",
      "(1, 810, 1.63)\n",
      "开始预测用户1对电影99114的评分...\n",
      "预测出用户1对物品99114的评分：3.91859\n",
      "(1, 99114, 3.92)\n",
      "开始预测用户1对电影830的评分...\n",
      "预测出用户1对物品830的评分：3.10402\n",
      "(1, 830, 3.1)\n",
      "开始预测用户1对电影832的评分...\n",
      "预测出用户1对物品832的评分：3.21231\n",
      "(1, 832, 3.21)\n",
      "开始预测用户1对电影836的评分...\n",
      "预测出用户1对物品836的评分：2.46158\n",
      "(1, 836, 2.46)\n",
      "开始预测用户1对电影837的评分...\n",
      "预测出用户1对物品837的评分：3.26029\n",
      "(1, 837, 3.26)\n",
      "开始预测用户1对电影838的评分...\n",
      "预测出用户1对物品838的评分：3.93297\n",
      "(1, 838, 3.93)\n",
      "开始预测用户1对电影839的评分...\n",
      "预测出用户1对物品839的评分：2.56189\n",
      "(1, 839, 2.56)\n",
      "开始预测用户1对电影842的评分...\n",
      "预测出用户1对物品842的评分：2.21317\n",
      "(1, 842, 2.21)\n",
      "开始预测用户1对电影140110的评分...\n",
      "预测出用户1对物品140110的评分：3.71513\n",
      "(1, 140110, 3.72)\n",
      "开始预测用户1对电影33615的评分...\n",
      "预测出用户1对物品33615的评分：3.31993\n",
      "(1, 33615, 3.32)\n",
      "开始预测用户1对电影849的评分...\n",
      "预测出用户1对物品849的评分：2.65158\n",
      "(1, 849, 2.65)\n",
      "开始预测用户1对电影852的评分...\n",
      "预测出用户1对物品852的评分：3.23247\n",
      "(1, 852, 3.23)\n",
      "开始预测用户1对电影107348的评分...\n",
      "预测出用户1对物品107348的评分：3.89248\n",
      "(1, 107348, 3.89)\n",
      "开始预测用户1对电影858的评分...\n",
      "预测出用户1对物品858的评分：4.39226\n",
      "(1, 858, 4.39)\n",
      "开始预测用户1对电影866的评分...\n",
      "预测出用户1对物品866的评分：3.83105\n",
      "(1, 866, 3.83)\n",
      "开始预测用户1对电影880的评分...\n",
      "预测出用户1对物品880的评分：2.32497\n",
      "(1, 880, 2.32)\n",
      "开始预测用户1对电影115569的评分...\n",
      "预测出用户1对物品115569的评分：4.48629\n",
      "(1, 115569, 4.49)\n",
      "开始预测用户1对电影892的评分...\n",
      "预测出用户1对物品892的评分：3.65954\n",
      "(1, 892, 3.66)\n",
      "开始预测用户1对电影33660的评分...\n",
      "预测出用户1对物品33660的评分：4.08564\n",
      "(1, 33660, 4.09)\n",
      "开始预测用户1对电影898的评分...\n",
      "预测出用户1对物品898的评分：4.31479\n",
      "(1, 898, 4.31)\n",
      "开始预测用户1对电影899的评分...\n",
      "预测出用户1对物品899的评分：4.07460\n",
      "(1, 899, 4.07)\n",
      "开始预测用户1对电影900的评分...\n",
      "预测出用户1对物品900的评分：4.06169\n",
      "(1, 900, 4.06)\n",
      "开始预测用户1对电影902的评分...\n",
      "预测出用户1对物品902的评分：3.97687\n",
      "(1, 902, 3.98)\n",
      "开始预测用户1对电影903的评分...\n",
      "预测出用户1对物品903的评分：4.02882\n",
      "(1, 903, 4.03)\n",
      "开始预测用户1对电影904的评分...\n",
      "预测出用户1对物品904的评分：4.19601\n",
      "(1, 904, 4.2)\n",
      "开始预测用户1对电影905的评分...\n",
      "预测出用户1对物品905的评分：4.10067\n",
      "(1, 905, 4.1)\n",
      "开始预测用户1对电影908的评分...\n",
      "预测出用户1对物品908的评分：4.20055\n",
      "(1, 908, 4.2)\n",
      "开始预测用户1对电影909的评分...\n",
      "预测出用户1对物品909的评分：4.07297\n",
      "(1, 909, 4.07)\n",
      "开始预测用户1对电影910的评分...\n",
      "预测出用户1对物品910的评分：4.16080\n",
      "(1, 910, 4.16)\n",
      "开始预测用户1对电影911的评分...\n",
      "预测出用户1对物品911的评分：3.74833\n",
      "(1, 911, 3.75)\n",
      "开始预测用户1对电影912的评分...\n",
      "预测出用户1对物品912的评分：4.40625\n",
      "(1, 912, 4.41)\n",
      "开始预测用户1对电影913的评分...\n",
      "预测出用户1对物品913的评分：4.08260\n",
      "(1, 913, 4.08)\n",
      "开始预测用户1对电影914的评分...\n",
      "预测出用户1对物品914的评分：4.13819\n",
      "(1, 914, 4.14)\n",
      "开始预测用户1对电影915的评分...\n",
      "预测出用户1对物品915的评分：3.96006\n",
      "(1, 915, 3.96)\n",
      "开始预测用户1对电影916的评分...\n",
      "预测出用户1对物品916的评分：4.36973\n",
      "(1, 916, 4.37)\n",
      "开始预测用户1对电影33679的评分...\n",
      "预测出用户1对物品33679的评分：3.30057\n",
      "(1, 33679, 3.3)\n",
      "开始预测用户1对电影50068的评分...\n",
      "预测出用户1对物品50068的评分：3.94550\n",
      "(1, 50068, 3.95)\n",
      "开始预测用户1对电影107406的评分...\n",
      "预测出用户1对物品107406的评分：3.82814\n",
      "(1, 107406, 3.83)\n",
      "开始预测用户1对电影920的评分...\n",
      "预测出用户1对物品920的评分：3.65681\n",
      "(1, 920, 3.66)\n",
      "开始预测用户1对电影922的评分...\n",
      "预测出用户1对物品922的评分：4.32290\n",
      "(1, 922, 4.32)\n",
      "开始预测用户1对电影924的评分...\n",
      "预测出用户1对物品924的评分：3.95911\n",
      "(1, 924, 3.96)\n",
      "开始预测用户1对电影926的评分...\n",
      "预测出用户1对物品926的评分：4.07020\n",
      "(1, 926, 4.07)\n",
      "开始预测用户1对电影928的评分...\n",
      "预测出用户1对物品928的评分：4.07829\n",
      "(1, 928, 4.08)\n",
      "开始预测用户1对电影115617的评分...\n",
      "预测出用户1对物品115617的评分：3.83390\n",
      "(1, 115617, 3.83)\n",
      "开始预测用户1对电影930的评分...\n",
      "预测出用户1对物品930的评分：4.17697\n",
      "(1, 930, 4.18)\n",
      "开始预测用户1对电影933的评分...\n",
      "预测出用户1对物品933的评分：4.35754\n",
      "(1, 933, 4.36)\n",
      "开始预测用户1对电影934的评分...\n",
      "预测出用户1对物品934的评分：3.46415\n",
      "(1, 934, 3.46)\n",
      "开始预测用户1对电影58293的评分...\n",
      "预测出用户1对物品58293的评分：2.55462\n",
      "(1, 58293, 2.55)\n",
      "开始预测用户1对电影951的评分...\n",
      "预测出用户1对物品951的评分：4.33866\n",
      "(1, 951, 4.34)\n",
      "开始预测用户1对电影952的评分...\n",
      "预测出用户1对物品952的评分：3.66010\n",
      "(1, 952, 3.66)\n",
      "开始预测用户1对电影953的评分...\n",
      "预测出用户1对物品953的评分：3.98529\n",
      "(1, 953, 3.99)\n",
      "开始预测用户1对电影58295的评分...\n",
      "预测出用户1对物品58295的评分：3.38056\n",
      "(1, 58295, 3.38)\n",
      "开始预测用户1对电影955的评分...\n",
      "预测出用户1对物品955的评分：3.99997\n",
      "(1, 955, 4.0)\n",
      "开始预测用户1对电影965的评分...\n",
      "预测出用户1对物品965的评分：3.74718\n",
      "(1, 965, 3.75)\n",
      "开始预测用户1对电影91077的评分...\n",
      "预测出用户1对物品91077的评分：3.74716\n",
      "(1, 91077, 3.75)\n",
      "开始预测用户1对电影968的评分...\n",
      "预测出用户1对物品968的评分：3.46824\n",
      "(1, 968, 3.47)\n",
      "开始预测用户1对电影969的评分...\n",
      "预测出用户1对物品969的评分：3.95363\n",
      "(1, 969, 3.95)\n",
      "开始预测用户1对电影986的评分...\n",
      "预测出用户1对物品986的评分：3.21567\n",
      "(1, 986, 3.22)\n",
      "开始预测用户1对电影991的评分...\n",
      "预测出用户1对物品991的评分：3.23034\n",
      "(1, 991, 3.23)\n",
      "开始预测用户1对电影994的评分...\n",
      "预测出用户1对物品994的评分：4.09058\n",
      "(1, 994, 4.09)\n",
      "开始预测用户1对电影996的评分...\n",
      "预测出用户1对物品996的评分：2.46192\n",
      "(1, 996, 2.46)\n",
      "开始预测用户1对电影999的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品999的评分：2.91432\n",
      "(1, 999, 2.91)\n",
      "开始预测用户1对电影1013的评分...\n",
      "预测出用户1对物品1013的评分：3.54470\n",
      "(1, 1013, 3.54)\n",
      "开始预测用户1对电影1015的评分...\n",
      "预测出用户1对物品1015的评分：2.90530\n",
      "(1, 1015, 2.91)\n",
      "开始预测用户1对电影1019的评分...\n",
      "预测出用户1对物品1019的评分：3.83989\n",
      "(1, 1019, 3.84)\n",
      "开始预测用户1对电影1020的评分...\n",
      "预测出用户1对物品1020的评分：3.04181\n",
      "(1, 1020, 3.04)\n",
      "开始预测用户1对电影1021的评分...\n",
      "预测出用户1对物品1021的评分：2.17492\n",
      "(1, 1021, 2.17)\n",
      "开始预测用户1对电影1022的评分...\n",
      "预测出用户1对物品1022的评分：3.82506\n",
      "(1, 1022, 3.83)\n",
      "开始预测用户1对电影115713的评分...\n",
      "预测出用户1对物品115713的评分：3.99409\n",
      "(1, 115713, 3.99)\n",
      "开始预测用户1对电影33794的评分...\n",
      "预测出用户1对物品33794的评分：3.85487\n",
      "(1, 33794, 3.85)\n",
      "开始预测用户1对电影1027的评分...\n",
      "预测出用户1对物品1027的评分：3.00898\n",
      "(1, 1027, 3.01)\n",
      "开始预测用户1对电影1028的评分...\n",
      "预测出用户1对物品1028的评分：3.90545\n",
      "(1, 1028, 3.91)\n",
      "开始预测用户1对电影1033的评分...\n",
      "预测出用户1对物品1033的评分：3.78824\n",
      "(1, 1033, 3.79)\n",
      "开始预测用户1对电影1035的评分...\n",
      "预测出用户1对物品1035的评分：3.87652\n",
      "(1, 1035, 3.88)\n",
      "开始预测用户1对电影1036的评分...\n",
      "预测出用户1对物品1036的评分：3.82318\n",
      "(1, 1036, 3.82)\n",
      "开始预测用户1对电影1037的评分...\n",
      "预测出用户1对物品1037的评分：2.50730\n",
      "(1, 1037, 2.51)\n",
      "开始预测用户1对电影41997的评分...\n",
      "预测出用户1对物品41997的评分：4.15682\n",
      "(1, 41997, 4.16)\n",
      "开始预测用户1对电影1041的评分...\n",
      "预测出用户1对物品1041的评分：4.76237\n",
      "(1, 1041, 4.76)\n",
      "开始预测用户1对电影1047的评分...\n",
      "预测出用户1对物品1047的评分：3.13351\n",
      "(1, 1047, 3.13)\n",
      "开始预测用户1对电影42011的评分...\n",
      "预测出用户1对物品42011的评分：2.36590\n",
      "(1, 42011, 2.37)\n",
      "开始预测用户1对电影1057的评分...\n",
      "预测出用户1对物品1057的评分：3.80700\n",
      "(1, 1057, 3.81)\n",
      "开始预测用户1对电影1059的评分...\n",
      "预测出用户1对物品1059的评分：3.74953\n",
      "(1, 1059, 3.75)\n",
      "开始预测用户1对电影1061的评分...\n",
      "预测出用户1对物品1061的评分：3.63331\n",
      "(1, 1061, 3.63)\n",
      "开始预测用户1对电影74789的评分...\n",
      "预测出用户1对物品74789的评分：3.09837\n",
      "(1, 74789, 3.1)\n",
      "开始预测用户1对电影1064的评分...\n",
      "预测出用户1对物品1064的评分：2.82714\n",
      "(1, 1064, 2.83)\n",
      "开始预测用户1对电影33836的评分...\n",
      "预测出用户1对物品33836的评分：2.26295\n",
      "(1, 33836, 2.26)\n",
      "开始预测用户1对电影1077的评分...\n",
      "预测出用户1对物品1077的评分：3.67364\n",
      "(1, 1077, 3.67)\n",
      "开始预测用户1对电影1078的评分...\n",
      "预测出用户1对物品1078的评分：3.90264\n",
      "(1, 1078, 3.9)\n",
      "开始预测用户1对电影1079的评分...\n",
      "预测出用户1对物品1079的评分：3.95368\n",
      "(1, 1079, 3.95)\n",
      "开始预测用户1对电影1081的评分...\n",
      "预测出用户1对物品1081的评分：3.15382\n",
      "(1, 1081, 3.15)\n",
      "开始预测用户1对电影1084的评分...\n",
      "预测出用户1对物品1084的评分：3.98923\n",
      "(1, 1084, 3.99)\n",
      "开始预测用户1对电影1086的评分...\n",
      "预测出用户1对物品1086的评分：4.13517\n",
      "(1, 1086, 4.14)\n",
      "开始预测用户1对电影1088的评分...\n",
      "预测出用户1对物品1088的评分：3.44387\n",
      "(1, 1088, 3.44)\n",
      "开始预测用户1对电影1091的评分...\n",
      "预测出用户1对物品1091的评分：2.47896\n",
      "(1, 1091, 2.48)\n",
      "开始预测用户1对电影1093的评分...\n",
      "预测出用户1对物品1093的评分：3.32790\n",
      "(1, 1093, 3.33)\n",
      "开始预测用户1对电影1094的评分...\n",
      "预测出用户1对物品1094的评分：3.40853\n",
      "(1, 1094, 3.41)\n",
      "开始预测用户1对电影1095的评分...\n",
      "预测出用户1对物品1095的评分：3.79971\n",
      "(1, 1095, 3.8)\n",
      "开始预测用户1对电影1100的评分...\n",
      "预测出用户1对物品1100的评分：2.39202\n",
      "(1, 1100, 2.39)\n",
      "开始预测用户1对电影1101的评分...\n",
      "预测出用户1对物品1101的评分：3.21338\n",
      "(1, 1101, 3.21)\n",
      "开始预测用户1对电影1103的评分...\n",
      "预测出用户1对物品1103的评分：3.96881\n",
      "(1, 1103, 3.97)\n",
      "开始预测用户1对电影1104的评分...\n",
      "预测出用户1对物品1104的评分：4.54743\n",
      "(1, 1104, 4.55)\n",
      "开始预测用户1对电影1120的评分...\n",
      "预测出用户1对物品1120的评分：3.63378\n",
      "(1, 1120, 3.63)\n",
      "开始预测用户1对电影1124的评分...\n",
      "预测出用户1对物品1124的评分：4.01896\n",
      "(1, 1124, 4.02)\n",
      "开始预测用户1对电影1125的评分...\n",
      "预测出用户1对物品1125的评分：3.82548\n",
      "(1, 1125, 3.83)\n",
      "开始预测用户1对电影1129的评分...\n",
      "预测出用户1对物品1129的评分：3.44430\n",
      "(1, 1129, 3.44)\n",
      "开始预测用户1对电影1131的评分...\n",
      "预测出用户1对物品1131的评分：4.23272\n",
      "(1, 1131, 4.23)\n",
      "开始预测用户1对电影1135的评分...\n",
      "预测出用户1对物品1135的评分：3.11358\n",
      "(1, 1135, 3.11)\n",
      "开始预测用户1对电影1148的评分...\n",
      "预测出用户1对物品1148的评分：4.09609\n",
      "(1, 1148, 4.1)\n",
      "开始预测用户1对电影148626的评分...\n",
      "预测出用户1对物品148626的评分：4.13894\n",
      "(1, 148626, 4.14)\n",
      "开始预测用户1对电影1171的评分...\n",
      "预测出用户1对物品1171的评分：3.62026\n",
      "(1, 1171, 3.62)\n",
      "开始预测用户1对电影1172的评分...\n",
      "预测出用户1对物品1172的评分：4.40751\n",
      "(1, 1172, 4.41)\n",
      "开始预测用户1对电影1173的评分...\n",
      "预测出用户1对物品1173的评分：3.07817\n",
      "(1, 1173, 3.08)\n",
      "开始预测用户1对电影1175的评分...\n",
      "预测出用户1对物品1175的评分：3.86788\n",
      "(1, 1175, 3.87)\n",
      "开始预测用户1对电影1178的评分...\n",
      "预测出用户1对物品1178的评分：4.57488\n",
      "(1, 1178, 4.57)\n",
      "开始预测用户1对电影1179的评分...\n",
      "预测出用户1对物品1179的评分：3.34780\n",
      "(1, 1179, 3.35)\n",
      "开始预测用户1对电影1183的评分...\n",
      "预测出用户1对物品1183的评分：3.89043\n",
      "(1, 1183, 3.89)\n",
      "开始预测用户1对电影1186的评分...\n",
      "预测出用户1对物品1186的评分：3.47523\n",
      "(1, 1186, 3.48)\n",
      "开始预测用户1对电影1188的评分...\n",
      "预测出用户1对物品1188的评分：4.13453\n",
      "(1, 1188, 4.13)\n",
      "开始预测用户1对电影1189的评分...\n",
      "预测出用户1对物品1189的评分：3.57451\n",
      "(1, 1189, 3.57)\n",
      "开始预测用户1对电影1193的评分...\n",
      "预测出用户1对物品1193的评分：4.19754\n",
      "(1, 1193, 4.2)\n",
      "开始预测用户1对电影1194的评分...\n",
      "预测出用户1对物品1194的评分：3.52609\n",
      "(1, 1194, 3.53)\n",
      "开始预测用户1对电影1199的评分...\n",
      "预测出用户1对物品1199的评分：4.29888\n",
      "(1, 1199, 4.3)\n",
      "开始预测用户1对电影1200的评分...\n",
      "预测出用户1对物品1200的评分：3.83588\n",
      "(1, 1200, 3.84)\n",
      "开始预测用户1对电影1201的评分...\n",
      "预测出用户1对物品1201的评分：4.27593\n",
      "(1, 1201, 4.28)\n",
      "开始预测用户1对电影1203的评分...\n",
      "预测出用户1对物品1203的评分：4.17014\n",
      "(1, 1203, 4.17)\n",
      "开始预测用户1对电影1204的评分...\n",
      "预测出用户1对物品1204的评分：4.22774\n",
      "(1, 1204, 4.23)\n",
      "开始预测用户1对电影1207的评分...\n",
      "预测出用户1对物品1207的评分：4.22259\n",
      "(1, 1207, 4.22)\n",
      "开始预测用户1对电影1209的评分...\n",
      "预测出用户1对物品1209的评分：4.40518\n",
      "(1, 1209, 4.41)\n",
      "开始预测用户1对电影1211的评分...\n",
      "预测出用户1对物品1211的评分：3.70679\n",
      "(1, 1211, 3.71)\n",
      "开始预测用户1对电影1212的评分...\n",
      "预测出用户1对物品1212的评分：4.20915\n",
      "(1, 1212, 4.21)\n",
      "开始预测用户1对电影83134的评分...\n",
      "预测出用户1对物品83134的评分：3.78165\n",
      "(1, 83134, 3.78)\n",
      "开始预测用户1对电影1215的评分...\n",
      "预测出用户1对物品1215的评分：3.95741\n",
      "(1, 1215, 3.96)\n",
      "开始预测用户1对电影1216的评分...\n",
      "预测出用户1对物品1216的评分：3.43037\n",
      "(1, 1216, 3.43)\n",
      "开始预测用户1对电影1217的评分...\n",
      "预测出用户1对物品1217的评分：4.56402\n",
      "(1, 1217, 4.56)\n",
      "开始预测用户1对电影1218的评分...\n",
      "预测出用户1对物品1218的评分：3.94397\n",
      "(1, 1218, 3.94)\n",
      "开始预测用户1对电影58559的评分...\n",
      "预测出用户1对物品58559的评分：4.16983\n",
      "(1, 58559, 4.17)\n",
      "开始预测用户1对电影1221的评分...\n",
      "预测出用户1对物品1221的评分：4.33533\n",
      "(1, 1221, 4.34)\n",
      "开始预测用户1对电影1223的评分...\n",
      "预测出用户1对物品1223的评分：4.32336\n",
      "(1, 1223, 4.32)\n",
      "开始预测用户1对电影1225的评分...\n",
      "预测出用户1对物品1225的评分：4.16126\n",
      "(1, 1225, 4.16)\n",
      "开始预测用户1对电影1227的评分...\n",
      "预测出用户1对物品1227的评分：4.40250\n",
      "(1, 1227, 4.4)\n",
      "开始预测用户1对电影1228的评分...\n",
      "预测出用户1对物品1228的评分：4.21544\n",
      "(1, 1228, 4.22)\n",
      "开始预测用户1对电影1230的评分...\n",
      "预测出用户1对物品1230的评分：4.09655\n",
      "(1, 1230, 4.1)\n",
      "开始预测用户1对电影1231的评分...\n",
      "预测出用户1对物品1231的评分：3.95938\n",
      "(1, 1231, 3.96)\n",
      "开始预测用户1对电影1233的评分...\n",
      "预测出用户1对物品1233的评分：4.36227\n",
      "(1, 1233, 4.36)\n",
      "开始预测用户1对电影1234的评分...\n",
      "预测出用户1对物品1234的评分：3.99803\n",
      "(1, 1234, 4.0)\n",
      "开始预测用户1对电影1235的评分...\n",
      "预测出用户1对物品1235的评分：4.63070\n",
      "(1, 1235, 4.63)\n",
      "开始预测用户1对电影1237的评分...\n",
      "预测出用户1对物品1237的评分：4.29731\n",
      "(1, 1237, 4.3)\n",
      "开始预测用户1对电影1242的评分...\n",
      "预测出用户1对物品1242的评分：4.06251\n",
      "(1, 1242, 4.06)\n",
      "开始预测用户1对电影1243的评分...\n",
      "预测出用户1对物品1243的评分：4.48161\n",
      "(1, 1243, 4.48)\n",
      "开始预测用户1对电影1244的评分...\n",
      "预测出用户1对物品1244的评分：4.11343\n",
      "(1, 1244, 4.11)\n",
      "开始预测用户1对电影1245的评分...\n",
      "预测出用户1对物品1245的评分：4.23136\n",
      "(1, 1245, 4.23)\n",
      "开始预测用户1对电影1246的评分...\n",
      "预测出用户1对物品1246的评分：4.15876\n",
      "(1, 1246, 4.16)\n",
      "开始预测用户1对电影1247的评分...\n",
      "预测出用户1对物品1247的评分：4.04824\n",
      "(1, 1247, 4.05)\n",
      "开始预测用户1对电影1248的评分...\n",
      "预测出用户1对物品1248的评分：4.30225\n",
      "(1, 1248, 4.3)\n",
      "开始预测用户1对电影1249的评分...\n",
      "预测出用户1对物品1249的评分：4.01975\n",
      "(1, 1249, 4.02)\n",
      "开始预测用户1对电影1250的评分...\n",
      "预测出用户1对物品1250的评分：4.23867\n",
      "(1, 1250, 4.24)\n",
      "开始预测用户1对电影1251的评分...\n",
      "预测出用户1对物品1251的评分：4.17881\n",
      "(1, 1251, 4.18)\n",
      "开始预测用户1对电影1252的评分...\n",
      "预测出用户1对物品1252的评分：4.28074\n",
      "(1, 1252, 4.28)\n",
      "开始预测用户1对电影1253的评分...\n",
      "预测出用户1对物品1253的评分：3.91460\n",
      "(1, 1253, 3.91)\n",
      "开始预测用户1对电影1254的评分...\n",
      "预测出用户1对物品1254的评分：3.50293\n",
      "(1, 1254, 3.5)\n",
      "开始预测用户1对电影1257的评分...\n",
      "预测出用户1对物品1257的评分：3.74972\n",
      "(1, 1257, 3.75)\n",
      "开始预测用户1对电影1259的评分...\n",
      "预测出用户1对物品1259的评分：4.02333\n",
      "(1, 1259, 4.02)\n",
      "开始预测用户1对电影1260的评分...\n",
      "预测出用户1对物品1260的评分：3.84749\n",
      "(1, 1260, 3.85)\n",
      "开始预测用户1对电影1261的评分...\n",
      "预测出用户1对物品1261的评分：3.93314\n",
      "(1, 1261, 3.93)\n",
      "开始预测用户1对电影1262的评分...\n",
      "预测出用户1对物品1262的评分：4.19178\n",
      "(1, 1262, 4.19)\n",
      "开始预测用户1对电影1263的评分...\n",
      "预测出用户1对物品1263的评分：3.94017\n",
      "(1, 1263, 3.94)\n",
      "开始预测用户1对电影1266的评分...\n",
      "预测出用户1对物品1266的评分：4.15992\n",
      "(1, 1266, 4.16)\n",
      "开始预测用户1对电影1267的评分...\n",
      "预测出用户1对物品1267的评分：4.23558\n",
      "(1, 1267, 4.24)\n",
      "开始预测用户1对电影1269的评分...\n",
      "预测出用户1对物品1269的评分：4.00368\n",
      "(1, 1269, 4.0)\n",
      "开始预测用户1对电影1271的评分...\n",
      "预测出用户1对物品1271的评分：3.31446\n",
      "(1, 1271, 3.31)\n",
      "开始预测用户1对电影1272的评分...\n",
      "预测出用户1对物品1272的评分：3.82665\n",
      "(1, 1272, 3.83)\n",
      "开始预测用户1对电影1273的评分...\n",
      "预测出用户1对物品1273的评分：3.87657\n",
      "(1, 1273, 3.88)\n",
      "开始预测用户1对电影1274的评分...\n",
      "预测出用户1对物品1274的评分：4.06940\n",
      "(1, 1274, 4.07)\n",
      "开始预测用户1对电影1276的评分...\n",
      "预测出用户1对物品1276的评分：4.39538\n",
      "(1, 1276, 4.4)\n",
      "开始预测用户1对电影1277的评分...\n",
      "预测出用户1对物品1277的评分：4.09587\n",
      "(1, 1277, 4.1)\n",
      "开始预测用户1对电影34048的评分...\n",
      "预测出用户1对物品34048的评分：2.96505\n",
      "(1, 34048, 2.97)\n",
      "开始预测用户1对电影1281的评分...\n",
      "预测出用户1对物品1281的评分：4.11994\n",
      "(1, 1281, 4.12)\n",
      "开始预测用户1对电影1283的评分...\n",
      "预测出用户1对物品1283的评分：4.06061\n",
      "(1, 1283, 4.06)\n",
      "开始预测用户1对电影1284的评分...\n",
      "预测出用户1对物品1284的评分：4.07434\n",
      "(1, 1284, 4.07)\n",
      "开始预测用户1对电影1285的评分...\n",
      "预测出用户1对物品1285的评分：3.95628\n",
      "(1, 1285, 3.96)\n",
      "开始预测用户1对电影1287的评分...\n",
      "预测出用户1对物品1287的评分：4.24546\n",
      "(1, 1287, 4.25)\n",
      "开始预测用户1对电影1288的评分...\n",
      "预测出用户1对物品1288的评分：4.00957\n",
      "(1, 1288, 4.01)\n",
      "开始预测用户1对电影1289的评分...\n",
      "预测出用户1对物品1289的评分：3.88159\n",
      "(1, 1289, 3.88)\n",
      "开始预测用户1对电影1292的评分...\n",
      "预测出用户1对物品1292的评分：4.16769\n",
      "(1, 1292, 4.17)\n",
      "开始预测用户1对电影1293的评分...\n",
      "预测出用户1对物品1293的评分：3.59553\n",
      "(1, 1293, 3.6)\n",
      "开始预测用户1对电影1295的评分...\n",
      "预测出用户1对物品1295的评分：2.93335\n",
      "(1, 1295, 2.93)\n",
      "开始预测用户1对电影1296的评分...\n",
      "预测出用户1对物品1296的评分：3.77544\n",
      "(1, 1296, 3.78)\n",
      "开始预测用户1对电影1297的评分...\n",
      "预测出用户1对物品1297的评分：3.97185\n",
      "(1, 1297, 3.97)\n",
      "开始预测用户1对电影1299的评分...\n",
      "预测出用户1对物品1299的评分：3.87174\n",
      "(1, 1299, 3.87)\n",
      "开始预测用户1对电影1301的评分...\n",
      "预测出用户1对物品1301的评分：3.39687\n",
      "(1, 1301, 3.4)\n",
      "开始预测用户1对电影1302的评分...\n",
      "预测出用户1对物品1302的评分：3.48164\n",
      "(1, 1302, 3.48)\n",
      "开始预测用户1对电影1303的评分...\n",
      "预测出用户1对物品1303的评分：4.12670\n",
      "(1, 1303, 4.13)\n",
      "开始预测用户1对电影1304的评分...\n",
      "预测出用户1对物品1304的评分：4.10498\n",
      "(1, 1304, 4.1)\n",
      "开始预测用户1对电影34072的评分...\n",
      "预测出用户1对物品34072的评分：3.71305\n",
      "(1, 34072, 3.71)\n",
      "开始预测用户1对电影1307的评分...\n",
      "预测出用户1对物品1307的评分：3.83371\n",
      "(1, 1307, 3.83)\n",
      "开始预测用户1对电影1320的评分...\n",
      "预测出用户1对物品1320的评分：3.25047\n",
      "(1, 1320, 3.25)\n",
      "开始预测用户1对电影1321的评分...\n",
      "预测出用户1对物品1321的评分：3.22774\n",
      "(1, 1321, 3.23)\n",
      "开始预测用户1对电影1327的评分...\n",
      "预测出用户1对物品1327的评分：2.53304\n",
      "(1, 1327, 2.53)\n",
      "开始预测用户1对电影1333的评分...\n",
      "预测出用户1对物品1333的评分：3.50088\n",
      "(1, 1333, 3.5)\n",
      "开始预测用户1对电影1339的评分...\n",
      "预测出用户1对物品1339的评分：3.58985\n",
      "(1, 1339, 3.59)\n",
      "开始预测用户1对电影1342的评分...\n",
      "预测出用户1对物品1342的评分：2.30953\n",
      "(1, 1342, 2.31)\n",
      "开始预测用户1对电影1343的评分...\n",
      "预测出用户1对物品1343的评分：3.70889\n",
      "(1, 1343, 3.71)\n",
      "开始预测用户1对电影1344的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品1344的评分：3.79639\n",
      "(1, 1344, 3.8)\n",
      "开始预测用户1对电影1345的评分...\n",
      "预测出用户1对物品1345的评分：3.34782\n",
      "(1, 1345, 3.35)\n",
      "开始预测用户1对电影1347的评分...\n",
      "预测出用户1对物品1347的评分：2.97946\n",
      "(1, 1347, 2.98)\n",
      "开始预测用户1对电影1350的评分...\n",
      "预测出用户1对物品1350的评分：3.73487\n",
      "(1, 1350, 3.73)\n",
      "开始预测用户1对电影1356的评分...\n",
      "预测出用户1对物品1356的评分：3.82222\n",
      "(1, 1356, 3.82)\n",
      "开始预测用户1对电影1357的评分...\n",
      "预测出用户1对物品1357的评分：3.82655\n",
      "(1, 1357, 3.83)\n",
      "开始预测用户1对电影1358的评分...\n",
      "预测出用户1对物品1358的评分：4.02382\n",
      "(1, 1358, 4.02)\n",
      "开始预测用户1对电影1359的评分...\n",
      "预测出用户1对物品1359的评分：2.42524\n",
      "(1, 1359, 2.43)\n",
      "开始预测用户1对电影1367的评分...\n",
      "预测出用户1对物品1367的评分：3.08465\n",
      "(1, 1367, 3.08)\n",
      "开始预测用户1对电影1370的评分...\n",
      "预测出用户1对物品1370的评分：3.20962\n",
      "(1, 1370, 3.21)\n",
      "开始预测用户1对电影1371的评分...\n",
      "预测出用户1对物品1371的评分：2.82833\n",
      "(1, 1371, 2.83)\n",
      "开始预测用户1对电影1372的评分...\n",
      "预测出用户1对物品1372的评分：3.32776\n",
      "(1, 1372, 3.33)\n",
      "开始预测用户1对电影1373的评分...\n",
      "预测出用户1对物品1373的评分：2.29310\n",
      "(1, 1373, 2.29)\n",
      "开始预测用户1对电影1374的评分...\n",
      "预测出用户1对物品1374的评分：3.80726\n",
      "(1, 1374, 3.81)\n",
      "开始预测用户1对电影1375的评分...\n",
      "预测出用户1对物品1375的评分：3.15871\n",
      "(1, 1375, 3.16)\n",
      "开始预测用户1对电影1376的评分...\n",
      "预测出用户1对物品1376的评分：3.15998\n",
      "(1, 1376, 3.16)\n",
      "开始预测用户1对电影1378的评分...\n",
      "预测出用户1对物品1378的评分：3.17327\n",
      "(1, 1378, 3.17)\n",
      "开始预测用户1对电影1379的评分...\n",
      "预测出用户1对物品1379的评分：3.11615\n",
      "(1, 1379, 3.12)\n",
      "开始预测用户1对电影1380的评分...\n",
      "预测出用户1对物品1380的评分：3.13391\n",
      "(1, 1380, 3.13)\n",
      "开始预测用户1对电影1381的评分...\n",
      "预测出用户1对物品1381的评分：1.99080\n",
      "(1, 1381, 1.99)\n",
      "开始预测用户1对电影34150的评分...\n",
      "预测出用户1对物品34150的评分：2.83856\n",
      "(1, 34150, 2.84)\n",
      "开始预测用户1对电影1385的评分...\n",
      "预测出用户1对物品1385的评分：2.57621\n",
      "(1, 1385, 2.58)\n",
      "开始预测用户1对电影1387的评分...\n",
      "预测出用户1对物品1387的评分：4.04214\n",
      "(1, 1387, 4.04)\n",
      "开始预测用户1对电影1388的评分...\n",
      "预测出用户1对物品1388的评分：2.48440\n",
      "(1, 1388, 2.48)\n",
      "开始预测用户1对电影91500的评分...\n",
      "预测出用户1对物品91500的评分：3.29271\n",
      "(1, 91500, 3.29)\n",
      "开始预测用户1对电影1391的评分...\n",
      "预测出用户1对物品1391的评分：2.98732\n",
      "(1, 1391, 2.99)\n",
      "开始预测用户1对电影1393的评分...\n",
      "预测出用户1对物品1393的评分：3.50506\n",
      "(1, 1393, 3.51)\n",
      "开始预测用户1对电影1394的评分...\n",
      "预测出用户1对物品1394的评分：3.94485\n",
      "(1, 1394, 3.94)\n",
      "开始预测用户1对电影34162的评分...\n",
      "预测出用户1对物品34162的评分：3.30888\n",
      "(1, 34162, 3.31)\n",
      "开始预测用户1对电影66934的评分...\n",
      "预测出用户1对物品66934的评分：3.69361\n",
      "(1, 66934, 3.69)\n",
      "开始预测用户1对电影1405的评分...\n",
      "预测出用户1对物品1405的评分：2.84099\n",
      "(1, 1405, 2.84)\n",
      "开始预测用户1对电影1407的评分...\n",
      "预测出用户1对物品1407的评分：2.90279\n",
      "(1, 1407, 2.9)\n",
      "开始预测用户1对电影1409的评分...\n",
      "预测出用户1对物品1409的评分：2.42823\n",
      "(1, 1409, 2.43)\n",
      "开始预测用户1对电影1411的评分...\n",
      "预测出用户1对物品1411的评分：3.97834\n",
      "(1, 1411, 3.98)\n",
      "开始预测用户1对电影1416的评分...\n",
      "预测出用户1对物品1416的评分：3.76510\n",
      "(1, 1416, 3.77)\n",
      "开始预测用户1对电影91529的评分...\n",
      "预测出用户1对物品91529的评分：4.06135\n",
      "(1, 91529, 4.06)\n",
      "开始预测用户1对电影91535的评分...\n",
      "预测出用户1对物品91535的评分：3.08605\n",
      "(1, 91535, 3.09)\n",
      "开始预测用户1对电影1429的评分...\n",
      "预测出用户1对物品1429的评分：4.00538\n",
      "(1, 1429, 4.01)\n",
      "开始预测用户1对电影83349的评分...\n",
      "预测出用户1对物品83349的评分：3.03708\n",
      "(1, 83349, 3.04)\n",
      "开始预测用户1对电影1431的评分...\n",
      "预测出用户1对物品1431的评分：2.44494\n",
      "(1, 1431, 2.44)\n",
      "开始预测用户1对电影91542的评分...\n",
      "预测出用户1对物品91542的评分：3.90750\n",
      "(1, 91542, 3.91)\n",
      "开始预测用户1对电影1438的评分...\n",
      "预测出用户1对物品1438的评分：2.15210\n",
      "(1, 1438, 2.15)\n",
      "开始预测用户1对电影1441的评分...\n",
      "预测出用户1对物品1441的评分：2.95070\n",
      "(1, 1441, 2.95)\n",
      "开始预测用户1对电影1449的评分...\n",
      "预测出用户1对物品1449的评分：3.89490\n",
      "(1, 1449, 3.89)\n",
      "开始预测用户1对电影1457的评分...\n",
      "预测出用户1对物品1457的评分：2.78785\n",
      "(1, 1457, 2.79)\n",
      "开始预测用户1对电影1459的评分...\n",
      "预测出用户1对物品1459的评分：2.41147\n",
      "(1, 1459, 2.41)\n",
      "开始预测用户1对电影58803的评分...\n",
      "预测出用户1对物品58803的评分：3.75109\n",
      "(1, 58803, 3.75)\n",
      "开始预测用户1对电影1464的评分...\n",
      "预测出用户1对物品1464的评分：3.15374\n",
      "(1, 1464, 3.15)\n",
      "开始预测用户1对电影1466的评分...\n",
      "预测出用户1对物品1466的评分：3.61558\n",
      "(1, 1466, 3.62)\n",
      "开始预测用户1对电影1474的评分...\n",
      "预测出用户1对物品1474的评分：1.97286\n",
      "(1, 1474, 1.97)\n",
      "开始预测用户1对电影1476的评分...\n",
      "预测出用户1对物品1476的评分：3.64027\n",
      "(1, 1476, 3.64)\n",
      "开始预测用户1对电影1479的评分...\n",
      "预测出用户1对物品1479的评分：2.99149\n",
      "(1, 1479, 2.99)\n",
      "开始预测用户1对电影1480的评分...\n",
      "预测出用户1对物品1480的评分：3.39456\n",
      "(1, 1480, 3.39)\n",
      "开始预测用户1对电影1483的评分...\n",
      "预测出用户1对物品1483的评分：2.41127\n",
      "(1, 1483, 2.41)\n",
      "开始预测用户1对电影1485的评分...\n",
      "预测出用户1对物品1485的评分：2.84037\n",
      "(1, 1485, 2.84)\n",
      "开始预测用户1对电影1488的评分...\n",
      "预测出用户1对物品1488的评分：2.15941\n",
      "(1, 1488, 2.16)\n",
      "开始预测用户1对电影1499的评分...\n",
      "预测出用户1对物品1499的评分：1.64400\n",
      "(1, 1499, 1.64)\n",
      "开始预测用户1对电影1513的评分...\n",
      "预测出用户1对物品1513的评分：2.90913\n",
      "(1, 1513, 2.91)\n",
      "开始预测用户1对电影1515的评分...\n",
      "预测出用户1对物品1515的评分：2.07203\n",
      "(1, 1515, 2.07)\n",
      "开始预测用户1对电影1518的评分...\n",
      "预测出用户1对物品1518的评分：3.05687\n",
      "(1, 1518, 3.06)\n",
      "开始预测用户1对电影91630的评分...\n",
      "预测出用户1对物品91630的评分：3.48782\n",
      "(1, 91630, 3.49)\n",
      "开始预测用户1对电影1527的评分...\n",
      "预测出用户1对物品1527的评分：3.75320\n",
      "(1, 1527, 3.75)\n",
      "开始预测用户1对电影1537的评分...\n",
      "预测出用户1对物品1537的评分：3.65807\n",
      "(1, 1537, 3.66)\n",
      "开始预测用户1对电影1544的评分...\n",
      "预测出用户1对物品1544的评分：2.58341\n",
      "(1, 1544, 2.58)\n",
      "开始预测用户1对电影91658的评分...\n",
      "预测出用户1对物品91658的评分：3.57192\n",
      "(1, 91658, 3.57)\n",
      "开始预测用户1对电影34319的评分...\n",
      "预测出用户1对物品34319的评分：3.19499\n",
      "(1, 34319, 3.19)\n",
      "开始预测用户1对电影67087的评分...\n",
      "预测出用户1对物品67087的评分：3.49420\n",
      "(1, 67087, 3.49)\n",
      "开始预测用户1对电影1556的评分...\n",
      "预测出用户1对物品1556的评分：1.20670\n",
      "(1, 1556, 1.21)\n",
      "开始预测用户1对电影1562的评分...\n",
      "预测出用户1对物品1562的评分：2.06474\n",
      "(1, 1562, 2.06)\n",
      "开始预测用户1对电影1566的评分...\n",
      "预测出用户1对物品1566的评分：3.59910\n",
      "(1, 1566, 3.6)\n",
      "开始预测用户1对电影1569的评分...\n",
      "预测出用户1对物品1569的评分：3.45587\n",
      "(1, 1569, 3.46)\n",
      "开始预测用户1对电影1584的评分...\n",
      "预测出用户1对物品1584的评分：3.42704\n",
      "(1, 1584, 3.43)\n",
      "开始预测用户1对电影1586的评分...\n",
      "预测出用户1对物品1586的评分：2.74701\n",
      "(1, 1586, 2.75)\n",
      "开始预测用户1对电影1588的评分...\n",
      "预测出用户1对物品1588的评分：2.55184\n",
      "(1, 1588, 2.55)\n",
      "开始预测用户1对电影1589的评分...\n",
      "预测出用户1对物品1589的评分：2.86255\n",
      "(1, 1589, 2.86)\n",
      "开始预测用户1对电影1590的评分...\n",
      "预测出用户1对物品1590的评分：2.95290\n",
      "(1, 1590, 2.95)\n",
      "开始预测用户1对电影1591的评分...\n",
      "预测出用户1对物品1591的评分：2.58972\n",
      "(1, 1591, 2.59)\n",
      "开始预测用户1对电影1597的评分...\n",
      "预测出用户1对物品1597的评分：2.85466\n",
      "(1, 1597, 2.85)\n",
      "开始预测用户1对电影1603的评分...\n",
      "预测出用户1对物品1603的评分：2.27120\n",
      "(1, 1603, 2.27)\n",
      "开始预测用户1对电影1608的评分...\n",
      "预测出用户1对物品1608的评分：3.28276\n",
      "(1, 1608, 3.28)\n",
      "开始预测用户1对电影1610的评分...\n",
      "预测出用户1对物品1610的评分：3.86222\n",
      "(1, 1610, 3.86)\n",
      "开始预测用户1对电影1614的评分...\n",
      "预测出用户1对物品1614的评分：2.75207\n",
      "(1, 1614, 2.75)\n",
      "开始预测用户1对电影1615的评分...\n",
      "预测出用户1对物品1615的评分：3.07820\n",
      "(1, 1615, 3.08)\n",
      "开始预测用户1对电影1616的评分...\n",
      "预测出用户1对物品1616的评分：2.77237\n",
      "(1, 1616, 2.77)\n",
      "开始预测用户1对电影1619的评分...\n",
      "预测出用户1对物品1619的评分：3.44099\n",
      "(1, 1619, 3.44)\n",
      "开始预测用户1对电影1635的评分...\n",
      "预测出用户1对物品1635的评分：3.87530\n",
      "(1, 1635, 3.88)\n",
      "开始预测用户1对电影34405的评分...\n",
      "预测出用户1对物品34405的评分：3.88627\n",
      "(1, 34405, 3.89)\n",
      "开始预测用户1对电影1639的评分...\n",
      "预测出用户1对物品1639的评分：3.40689\n",
      "(1, 1639, 3.41)\n",
      "开始预测用户1对电影1641的评分...\n",
      "预测出用户1对物品1641的评分：3.80967\n",
      "(1, 1641, 3.81)\n",
      "开始预测用户1对电影1645的评分...\n",
      "预测出用户1对物品1645的评分：3.39136\n",
      "(1, 1645, 3.39)\n",
      "开始预测用户1对电影157296的评分...\n",
      "预测出用户1对物品157296的评分：3.31326\n",
      "(1, 157296, 3.31)\n",
      "开始预测用户1对电影1653的评分...\n",
      "预测出用户1对物品1653的评分：3.98255\n",
      "(1, 1653, 3.98)\n",
      "开始预测用户1对电影58998的评分...\n",
      "预测出用户1对物品58998的评分：3.91128\n",
      "(1, 58998, 3.91)\n",
      "开始预测用户1对电影1663的评分...\n",
      "预测出用户1对物品1663的评分：3.86263\n",
      "(1, 1663, 3.86)\n",
      "开始预测用户1对电影1665的评分...\n",
      "预测出用户1对物品1665的评分：2.71216\n",
      "(1, 1665, 2.71)\n",
      "开始预测用户1对电影34437的评分...\n",
      "预测出用户1对物品34437的评分：3.41039\n",
      "(1, 34437, 3.41)\n",
      "开始预测用户1对电影1672的评分...\n",
      "预测出用户1对物品1672的评分：3.19981\n",
      "(1, 1672, 3.2)\n",
      "开始预测用户1对电影1673的评分...\n",
      "预测出用户1对物品1673的评分：4.09256\n",
      "(1, 1673, 4.09)\n",
      "开始预测用户1对电影1674的评分...\n",
      "预测出用户1对物品1674的评分：3.66525\n",
      "(1, 1674, 3.67)\n",
      "开始预测用户1对电影59022的评分...\n",
      "预测出用户1对物品59022的评分：3.11817\n",
      "(1, 59022, 3.12)\n",
      "开始预测用户1对电影1680的评分...\n",
      "预测出用户1对物品1680的评分：3.63569\n",
      "(1, 1680, 3.64)\n",
      "开始预测用户1对电影1682的评分...\n",
      "预测出用户1对物品1682的评分：3.86125\n",
      "(1, 1682, 3.86)\n",
      "开始预测用户1对电影1687的评分...\n",
      "预测出用户1对物品1687的评分：2.77781\n",
      "(1, 1687, 2.78)\n",
      "开始预测用户1对电影1688的评分...\n",
      "预测出用户1对物品1688的评分：3.49045\n",
      "(1, 1688, 3.49)\n",
      "开始预测用户1对电影1690的评分...\n",
      "预测出用户1对物品1690的评分：2.78866\n",
      "(1, 1690, 2.79)\n",
      "开始预测用户1对电影1693的评分...\n",
      "预测出用户1对物品1693的评分：3.31802\n",
      "(1, 1693, 3.32)\n",
      "开始预测用户1对电影108190的评分...\n",
      "预测出用户1对物品108190的评分：3.22373\n",
      "(1, 108190, 3.22)\n",
      "开始预测用户1对电影1702的评分...\n",
      "预测出用户1对物品1702的评分：2.84655\n",
      "(1, 1702, 2.85)\n",
      "开始预测用户1对电影1704的评分...\n",
      "预测出用户1对物品1704的评分：4.11382\n",
      "(1, 1704, 4.11)\n",
      "开始预测用户1对电影1711的评分...\n",
      "预测出用户1对物品1711的评分：2.97181\n",
      "(1, 1711, 2.97)\n",
      "开始预测用户1对电影1717的评分...\n",
      "预测出用户1对物品1717的评分：2.73639\n",
      "(1, 1717, 2.74)\n",
      "开始预测用户1对电影1719的评分...\n",
      "预测出用户1对物品1719的评分：4.20374\n",
      "(1, 1719, 4.2)\n",
      "开始预测用户1对电影50872的评分...\n",
      "预测出用户1对物品50872的评分：3.93007\n",
      "(1, 50872, 3.93)\n",
      "开始预测用户1对电影1721的评分...\n",
      "预测出用户1对物品1721的评分：3.37670\n",
      "(1, 1721, 3.38)\n",
      "开始预测用户1对电影1722的评分...\n",
      "预测出用户1对物品1722的评分：2.85177\n",
      "(1, 1722, 2.85)\n",
      "开始预测用户1对电影67255的评分...\n",
      "预测出用户1对物品67255的评分：4.11439\n",
      "(1, 67255, 4.11)\n",
      "开始预测用户1对电影1726的评分...\n",
      "预测出用户1对物品1726的评分：2.41808\n",
      "(1, 1726, 2.42)\n",
      "开始预测用户1对电影1729的评分...\n",
      "预测出用户1对物品1729的评分：3.75183\n",
      "(1, 1729, 3.75)\n",
      "开始预测用户1对电影1735的评分...\n",
      "预测出用户1对物品1735的评分：3.16871\n",
      "(1, 1735, 3.17)\n",
      "开始预测用户1对电影1747的评分...\n",
      "预测出用户1对物品1747的评分：3.15547\n",
      "(1, 1747, 3.16)\n",
      "开始预测用户1对电影1748的评分...\n",
      "预测出用户1对物品1748的评分：3.90482\n",
      "(1, 1748, 3.9)\n",
      "开始预测用户1对电影34520的评分...\n",
      "预测出用户1对物品34520的评分：2.19305\n",
      "(1, 34520, 2.19)\n",
      "开始预测用户1对电影1753的评分...\n",
      "预测出用户1对物品1753的评分：3.68401\n",
      "(1, 1753, 3.68)\n",
      "开始预测用户1对电影1754的评分...\n",
      "预测出用户1对物品1754的评分：3.46835\n",
      "(1, 1754, 3.47)\n",
      "开始预测用户1对电影42723的评分...\n",
      "预测出用户1对物品42723的评分：2.36461\n",
      "(1, 42723, 2.36)\n",
      "开始预测用户1对电影1769的评分...\n",
      "预测出用户1对物品1769的评分：2.69867\n",
      "(1, 1769, 2.7)\n",
      "开始预测用户1对电影1772的评分...\n",
      "预测出用户1对物品1772的评分：2.47988\n",
      "(1, 1772, 2.48)\n",
      "开始预测用户1对电影42738的评分...\n",
      "预测出用户1对物品42738的评分：3.23615\n",
      "(1, 42738, 3.24)\n",
      "开始预测用户1对电影1779的评分...\n",
      "预测出用户1对物品1779的评分：2.61785\n",
      "(1, 1779, 2.62)\n",
      "开始预测用户1对电影1784的评分...\n",
      "预测出用户1对物品1784的评分：3.64897\n",
      "(1, 1784, 3.65)\n",
      "开始预测用户1对电影1792的评分...\n",
      "预测出用户1对物品1792的评分：2.79356\n",
      "(1, 1792, 2.79)\n",
      "开始预测用户1对电影1799的评分...\n",
      "预测出用户1对物品1799的评分：3.48987\n",
      "(1, 1799, 3.49)\n",
      "开始预测用户1对电影1801的评分...\n",
      "预测出用户1对物品1801的评分：3.20439\n",
      "(1, 1801, 3.2)\n",
      "开始预测用户1对电影1810的评分...\n",
      "预测出用户1对物品1810的评分：3.52094\n",
      "(1, 1810, 3.52)\n",
      "开始预测用户1对电影1831的评分...\n",
      "预测出用户1对物品1831的评分：2.14310\n",
      "(1, 1831, 2.14)\n",
      "开始预测用户1对电影1833的评分...\n",
      "预测出用户1对物品1833的评分：2.93169\n",
      "(1, 1833, 2.93)\n",
      "开始预测用户1对电影1834的评分...\n",
      "预测出用户1对物品1834的评分：3.77549\n",
      "(1, 1834, 3.78)\n",
      "开始预测用户1对电影1835的评分...\n",
      "预测出用户1对物品1835的评分：3.34242\n",
      "(1, 1835, 3.34)\n",
      "开始预测用户1对电影1845的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品1845的评分：3.81326\n",
      "(1, 1845, 3.81)\n",
      "开始预测用户1对电影1848的评分...\n",
      "预测出用户1对物品1848的评分：2.74625\n",
      "(1, 1848, 2.75)\n",
      "开始预测用户1对电影1876的评分...\n",
      "预测出用户1对物品1876的评分：2.78014\n",
      "(1, 1876, 2.78)\n",
      "开始预测用户1对电影1882的评分...\n",
      "预测出用户1对物品1882的评分：1.84199\n",
      "(1, 1882, 1.84)\n",
      "开始预测用户1对电影1883的评分...\n",
      "预测出用户1对物品1883的评分：3.35705\n",
      "(1, 1883, 3.36)\n",
      "开始预测用户1对电影1884的评分...\n",
      "预测出用户1对物品1884的评分：3.93876\n",
      "(1, 1884, 3.94)\n",
      "开始预测用户1对电影1885的评分...\n",
      "预测出用户1对物品1885的评分：2.93741\n",
      "(1, 1885, 2.94)\n",
      "开始预测用户1对电影1892的评分...\n",
      "预测出用户1对物品1892的评分：3.11623\n",
      "(1, 1892, 3.12)\n",
      "开始预测用户1对电影1894的评分...\n",
      "预测出用户1对物品1894的评分：2.66649\n",
      "(1, 1894, 2.67)\n",
      "开始预测用户1对电影1895的评分...\n",
      "预测出用户1对物品1895的评分：2.94422\n",
      "(1, 1895, 2.94)\n",
      "开始预测用户1对电影1907的评分...\n",
      "预测出用户1对物品1907的评分：3.64221\n",
      "(1, 1907, 3.64)\n",
      "开始预测用户1对电影1909的评分...\n",
      "预测出用户1对物品1909的评分：3.42114\n",
      "(1, 1909, 3.42)\n",
      "开始预测用户1对电影1911的评分...\n",
      "预测出用户1对物品1911的评分：2.57187\n",
      "(1, 1911, 2.57)\n",
      "开始预测用户1对电影1912的评分...\n",
      "预测出用户1对物品1912的评分：3.94090\n",
      "(1, 1912, 3.94)\n",
      "开始预测用户1对电影59258的评分...\n",
      "预测出用户1对物品59258的评分：3.71775\n",
      "(1, 59258, 3.72)\n",
      "开始预测用户1对电影1916的评分...\n",
      "预测出用户1对物品1916的评分：3.41829\n",
      "(1, 1916, 3.42)\n",
      "开始预测用户1对电影1917的评分...\n",
      "预测出用户1对物品1917的评分：2.87697\n",
      "(1, 1917, 2.88)\n",
      "开始预测用户1对电影1918的评分...\n",
      "预测出用户1对物品1918的评分：2.91901\n",
      "(1, 1918, 2.92)\n",
      "开始预测用户1对电影1921的评分...\n",
      "预测出用户1对物品1921的评分：3.94793\n",
      "(1, 1921, 3.95)\n",
      "开始预测用户1对电影1923的评分...\n",
      "预测出用户1对物品1923的评分：3.77065\n",
      "(1, 1923, 3.77)\n",
      "开始预测用户1对电影51077的评分...\n",
      "预测出用户1对物品51077的评分：2.36660\n",
      "(1, 51077, 2.37)\n",
      "开始预测用户1对电影51086的评分...\n",
      "预测出用户1对物品51086的评分：3.33731\n",
      "(1, 51086, 3.34)\n",
      "开始预测用户1对电影1944的评分...\n",
      "预测出用户1对物品1944的评分：3.81899\n",
      "(1, 1944, 3.82)\n",
      "开始预测用户1对电影1945的评分...\n",
      "预测出用户1对物品1945的评分：4.22095\n",
      "(1, 1945, 4.22)\n",
      "开始预测用户1对电影1947的评分...\n",
      "预测出用户1对物品1947的评分：3.40566\n",
      "(1, 1947, 3.41)\n",
      "开始预测用户1对电影1950的评分...\n",
      "预测出用户1对物品1950的评分：4.20156\n",
      "(1, 1950, 4.2)\n",
      "开始预测用户1对电影1952的评分...\n",
      "预测出用户1对物品1952的评分：3.93819\n",
      "(1, 1952, 3.94)\n",
      "开始预测用户1对电影1953的评分...\n",
      "预测出用户1对物品1953的评分：3.85240\n",
      "(1, 1953, 3.85)\n",
      "开始预测用户1对电影1955的评分...\n",
      "预测出用户1对物品1955的评分：3.98494\n",
      "(1, 1955, 3.98)\n",
      "开始预测用户1对电影1956的评分...\n",
      "预测出用户1对物品1956的评分：4.04046\n",
      "(1, 1956, 4.04)\n",
      "开始预测用户1对电影1957的评分...\n",
      "预测出用户1对物品1957的评分：3.78651\n",
      "(1, 1957, 3.79)\n",
      "开始预测用户1对电影1958的评分...\n",
      "预测出用户1对物品1958的评分：3.73237\n",
      "(1, 1958, 3.73)\n",
      "开始预测用户1对电影1959的评分...\n",
      "预测出用户1对物品1959的评分：3.48049\n",
      "(1, 1959, 3.48)\n",
      "开始预测用户1对电影1960的评分...\n",
      "预测出用户1对物品1960的评分：3.45656\n",
      "(1, 1960, 3.46)\n",
      "开始预测用户1对电影1961的评分...\n",
      "预测出用户1对物品1961的评分：3.96279\n",
      "(1, 1961, 3.96)\n",
      "开始预测用户1对电影1962的评分...\n",
      "预测出用户1对物品1962的评分：3.73851\n",
      "(1, 1962, 3.74)\n",
      "开始预测用户1对电影1963的评分...\n",
      "预测出用户1对物品1963的评分：3.50098\n",
      "(1, 1963, 3.5)\n",
      "开始预测用户1对电影1965的评分...\n",
      "预测出用户1对物品1965的评分：3.49728\n",
      "(1, 1965, 3.5)\n",
      "开始预测用户1对电影1968的评分...\n",
      "预测出用户1对物品1968的评分：3.71406\n",
      "(1, 1968, 3.71)\n",
      "开始预测用户1对电影1970的评分...\n",
      "预测出用户1对物品1970的评分：2.50531\n",
      "(1, 1970, 2.51)\n",
      "开始预测用户1对电影59315的评分...\n",
      "预测出用户1对物品59315的评分：3.89390\n",
      "(1, 59315, 3.89)\n",
      "开始预测用户1对电影1974的评分...\n",
      "预测出用户1对物品1974的评分：2.51642\n",
      "(1, 1974, 2.52)\n",
      "开始预测用户1对电影1982的评分...\n",
      "预测出用户1对物品1982的评分：3.49643\n",
      "(1, 1982, 3.5)\n",
      "开始预测用户1对电影1991的评分...\n",
      "预测出用户1对物品1991的评分：2.54716\n",
      "(1, 1991, 2.55)\n",
      "开始预测用户1对电影1994的评分...\n",
      "预测出用户1对物品1994的评分：3.22311\n",
      "(1, 1994, 3.22)\n",
      "开始预测用户1对电影1997的评分...\n",
      "预测出用户1对物品1997的评分：3.94627\n",
      "(1, 1997, 3.95)\n",
      "开始预测用户1对电影2001的评分...\n",
      "预测出用户1对物品2001的评分：3.19555\n",
      "(1, 2001, 3.2)\n",
      "开始预测用户1对电影2002的评分...\n",
      "预测出用户1对物品2002的评分：2.95608\n",
      "(1, 2002, 2.96)\n",
      "开始预测用户1对电影2003的评分...\n",
      "预测出用户1对物品2003的评分：3.42948\n",
      "(1, 2003, 3.43)\n",
      "开始预测用户1对电影2004的评分...\n",
      "预测出用户1对物品2004的评分：3.19282\n",
      "(1, 2004, 3.19)\n",
      "开始预测用户1对电影2006的评分...\n",
      "预测出用户1对物品2006的评分：2.79055\n",
      "(1, 2006, 2.79)\n",
      "开始预测用户1对电影2009的评分...\n",
      "预测出用户1对物品2009的评分：3.48295\n",
      "(1, 2009, 3.48)\n",
      "开始预测用户1对电影2010的评分...\n",
      "预测出用户1对物品2010的评分：3.65791\n",
      "(1, 2010, 3.66)\n",
      "开始预测用户1对电影2011的评分...\n",
      "预测出用户1对物品2011的评分：3.50411\n",
      "(1, 2011, 3.5)\n",
      "开始预测用户1对电影2013的评分...\n",
      "预测出用户1对物品2013的评分：2.92585\n",
      "(1, 2013, 2.93)\n",
      "开始预测用户1对电影2019的评分...\n",
      "预测出用户1对物品2019的评分：4.34224\n",
      "(1, 2019, 4.34)\n",
      "开始预测用户1对电影2020的评分...\n",
      "预测出用户1对物品2020的评分：3.75772\n",
      "(1, 2020, 3.76)\n",
      "开始预测用户1对电影2021的评分...\n",
      "预测出用户1对物品2021的评分：3.37004\n",
      "(1, 2021, 3.37)\n",
      "开始预测用户1对电影2023的评分...\n",
      "预测出用户1对物品2023的评分：3.51371\n",
      "(1, 2023, 3.51)\n",
      "开始预测用户1对电影174055的评分...\n",
      "预测出用户1对物品174055的评分：3.92971\n",
      "(1, 174055, 3.93)\n",
      "开始预测用户1对电影59369的评分...\n",
      "预测出用户1对物品59369的评分：3.28298\n",
      "(1, 59369, 3.28)\n",
      "开始预测用户1对电影59387的评分...\n",
      "预测出用户1对物品59387的评分：4.31860\n",
      "(1, 59387, 4.32)\n",
      "开始预测用户1对电影2052的评分...\n",
      "预测出用户1对物品2052的评分：2.43589\n",
      "(1, 2052, 2.44)\n",
      "开始预测用户1对电影2053的评分...\n",
      "预测出用户1对物品2053的评分：1.99886\n",
      "(1, 2053, 2.0)\n",
      "开始预测用户1对电影2059的评分...\n",
      "预测出用户1对物品2059的评分：3.00179\n",
      "(1, 2059, 3.0)\n",
      "开始预测用户1对电影2060的评分...\n",
      "预测出用户1对物品2060的评分：3.33432\n",
      "(1, 2060, 3.33)\n",
      "开始预测用户1对电影2064的评分...\n",
      "预测出用户1对物品2064的评分：3.90306\n",
      "(1, 2064, 3.9)\n",
      "开始预测用户1对电影2065的评分...\n",
      "预测出用户1对物品2065的评分：3.92865\n",
      "(1, 2065, 3.93)\n",
      "开始预测用户1对电影2067的评分...\n",
      "预测出用户1对物品2067的评分：4.29461\n",
      "(1, 2067, 4.29)\n",
      "开始预测用户1对电影2072的评分...\n",
      "预测出用户1对物品2072的评分：3.24364\n",
      "(1, 2072, 3.24)\n",
      "开始预测用户1对电影2076的评分...\n",
      "预测出用户1对物品2076的评分：3.98042\n",
      "(1, 2076, 3.98)\n",
      "开始预测用户1对电影2080的评分...\n",
      "预测出用户1对物品2080的评分：3.70612\n",
      "(1, 2080, 3.71)\n",
      "开始预测用户1对电影2081的评分...\n",
      "预测出用户1对物品2081的评分：3.68757\n",
      "(1, 2081, 3.69)\n",
      "开始预测用户1对电影2082的评分...\n",
      "预测出用户1对物品2082的评分：2.60239\n",
      "(1, 2082, 2.6)\n",
      "开始预测用户1对电影2083的评分...\n",
      "预测出用户1对物品2083的评分：3.90257\n",
      "(1, 2083, 3.9)\n",
      "开始预测用户1对电影2085的评分...\n",
      "预测出用户1对物品2085的评分：3.48486\n",
      "(1, 2085, 3.48)\n",
      "开始预测用户1对电影26662的评分...\n",
      "预测出用户1对物品26662的评分：4.07233\n",
      "(1, 26662, 4.07)\n",
      "开始预测用户1对电影2087的评分...\n",
      "预测出用户1对物品2087的评分：3.87395\n",
      "(1, 2087, 3.87)\n",
      "开始预测用户1对电影2088的评分...\n",
      "预测出用户1对物品2088的评分：2.41467\n",
      "(1, 2088, 2.41)\n",
      "开始预测用户1对电影2100的评分...\n",
      "预测出用户1对物品2100的评分：2.93583\n",
      "(1, 2100, 2.94)\n",
      "开始预测用户1对电影51255的评分...\n",
      "预测出用户1对物品51255的评分：3.98225\n",
      "(1, 51255, 3.98)\n",
      "开始预测用户1对电影2108的评分...\n",
      "预测出用户1对物品2108的评分：3.51959\n",
      "(1, 2108, 3.52)\n",
      "开始预测用户1对电影2109的评分...\n",
      "预测出用户1对物品2109的评分：3.49062\n",
      "(1, 2109, 3.49)\n",
      "开始预测用户1对电影2110的评分...\n",
      "预测出用户1对物品2110的评分：3.39745\n",
      "(1, 2110, 3.4)\n",
      "开始预测用户1对电影116797的评分...\n",
      "预测出用户1对物品116797的评分：4.36243\n",
      "(1, 116797, 4.36)\n",
      "开始预测用户1对电影2114的评分...\n",
      "预测出用户1对物品2114的评分：3.85964\n",
      "(1, 2114, 3.86)\n",
      "开始预测用户1对电影2117的评分...\n",
      "预测出用户1对物品2117的评分：3.45439\n",
      "(1, 2117, 3.45)\n",
      "开始预测用户1对电影2118的评分...\n",
      "预测出用户1对物品2118的评分：3.49231\n",
      "(1, 2118, 3.49)\n",
      "开始预测用户1对电影2122的评分...\n",
      "预测出用户1对物品2122的评分：2.39008\n",
      "(1, 2122, 2.39)\n",
      "开始预测用户1对电影2123的评分...\n",
      "预测出用户1对物品2123的评分：2.83441\n",
      "(1, 2123, 2.83)\n",
      "开始预测用户1对电影2124的评分...\n",
      "预测出用户1对物品2124的评分：3.17058\n",
      "(1, 2124, 3.17)\n",
      "开始预测用户1对电影2125的评分...\n",
      "预测出用户1对物品2125的评分：3.38849\n",
      "(1, 2125, 3.39)\n",
      "开始预测用户1对电影2126的评分...\n",
      "预测出用户1对物品2126的评分：2.71707\n",
      "(1, 2126, 2.72)\n",
      "开始预测用户1对电影2133的评分...\n",
      "预测出用户1对物品2133的评分：3.47747\n",
      "(1, 2133, 3.48)\n",
      "开始预测用户1对电影2134的评分...\n",
      "预测出用户1对物品2134的评分：3.21185\n",
      "(1, 2134, 3.21)\n",
      "开始预测用户1对电影2135的评分...\n",
      "预测出用户1对物品2135的评分：4.00253\n",
      "(1, 2135, 4.0)\n",
      "开始预测用户1对电影2136的评分...\n",
      "预测出用户1对物品2136的评分：2.27122\n",
      "(1, 2136, 2.27)\n",
      "开始预测用户1对电影116823的评分...\n",
      "预测出用户1对物品116823的评分：3.84868\n",
      "(1, 116823, 3.85)\n",
      "开始预测用户1对电影2140的评分...\n",
      "预测出用户1对物品2140的评分：3.61776\n",
      "(1, 2140, 3.62)\n",
      "开始预测用户1对电影2144的评分...\n",
      "预测出用户1对物品2144的评分：3.67057\n",
      "(1, 2144, 3.67)\n",
      "开始预测用户1对电影2145的评分...\n",
      "预测出用户1对物品2145的评分：3.28424\n",
      "(1, 2145, 3.28)\n",
      "开始预测用户1对电影2146的评分...\n",
      "预测出用户1对物品2146的评分：3.40428\n",
      "(1, 2146, 3.4)\n",
      "开始预测用户1对电影92259的评分...\n",
      "预测出用户1对物品92259的评分：4.22817\n",
      "(1, 92259, 4.23)\n",
      "开始预测用户1对电影2150的评分...\n",
      "预测出用户1对物品2150的评分：3.94074\n",
      "(1, 2150, 3.94)\n",
      "开始预测用户1对电影2153的评分...\n",
      "预测出用户1对物品2153的评分：2.34351\n",
      "(1, 2153, 2.34)\n",
      "开始预测用户1对电影59501的评分...\n",
      "预测出用户1对物品59501的评分：3.56355\n",
      "(1, 59501, 3.56)\n",
      "开始预测用户1对电影2160的评分...\n",
      "预测出用户1对物品2160的评分：4.18429\n",
      "(1, 2160, 4.18)\n",
      "开始预测用户1对电影2167的评分...\n",
      "预测出用户1对物品2167的评分：3.25485\n",
      "(1, 2167, 3.25)\n",
      "开始预测用户1对电影2186的评分...\n",
      "预测出用户1对物品2186的评分：4.20911\n",
      "(1, 2186, 4.21)\n",
      "开始预测用户1对电影2194的评分...\n",
      "预测出用户1对物品2194的评分：3.94221\n",
      "(1, 2194, 3.94)\n",
      "开始预测用户1对电影67734的评分...\n",
      "预测出用户1对物品67734的评分：3.54745\n",
      "(1, 67734, 3.55)\n",
      "开始预测用户1对电影26776的评分...\n",
      "预测出用户1对物品26776的评分：4.26641\n",
      "(1, 26776, 4.27)\n",
      "开始预测用户1对电影2231的评分...\n",
      "预测出用户1对物品2231的评分：3.84173\n",
      "(1, 2231, 3.84)\n",
      "开始预测用户1对电影2232的评分...\n",
      "预测出用户1对物品2232的评分：3.46480\n",
      "(1, 2232, 3.46)\n",
      "开始预测用户1对电影84152的评分...\n",
      "预测出用户1对物品84152的评分：4.02911\n",
      "(1, 84152, 4.03)\n",
      "开始预测用户1对电影2243的评分...\n",
      "预测出用户1对物品2243的评分：3.74183\n",
      "(1, 2243, 3.74)\n",
      "开始预测用户1对电影2245的评分...\n",
      "预测出用户1对物品2245的评分：3.27479\n",
      "(1, 2245, 3.27)\n",
      "开始预测用户1对电影2247的评分...\n",
      "预测出用户1对物品2247的评分：2.92436\n",
      "(1, 2247, 2.92)\n",
      "开始预测用户1对电影2248的评分...\n",
      "预测出用户1对物品2248的评分：3.92468\n",
      "(1, 2248, 3.92)\n",
      "开始预测用户1对电影2249的评分...\n",
      "预测出用户1对物品2249的评分：2.73983\n",
      "(1, 2249, 2.74)\n",
      "开始预测用户1对电影51412的评分...\n",
      "预测出用户1对物品51412的评分：2.50098\n",
      "(1, 51412, 2.5)\n",
      "开始预测用户1对电影59615的评分...\n",
      "预测出用户1对物品59615的评分：2.69941\n",
      "(1, 59615, 2.7)\n",
      "开始预测用户1对电影2278的评分...\n",
      "预测出用户1对物品2278的评分：3.47241\n",
      "(1, 2278, 3.47)\n",
      "开始预测用户1对电影2288的评分...\n",
      "预测出用户1对物品2288的评分：4.06965\n",
      "(1, 2288, 4.07)\n",
      "开始预测用户1对电影2289的评分...\n",
      "预测出用户1对物品2289的评分：3.97478\n",
      "(1, 2289, 3.97)\n",
      "开始预测用户1对电影2294的评分...\n",
      "预测出用户1对物品2294的评分：3.27587\n",
      "(1, 2294, 3.28)\n",
      "开始预测用户1对电影2297的评分...\n",
      "预测出用户1对物品2297的评分：3.46565\n",
      "(1, 2297, 3.47)\n",
      "开始预测用户1对电影2300的评分...\n",
      "预测出用户1对物品2300的评分：4.14836\n",
      "(1, 2300, 4.15)\n",
      "开始预测用户1对电影2301的评分...\n",
      "预测出用户1对物品2301的评分：3.47806\n",
      "(1, 2301, 3.48)\n",
      "开始预测用户1对电影2302的评分...\n",
      "预测出用户1对物品2302的评分：3.29191\n",
      "(1, 2302, 3.29)\n",
      "开始预测用户1对电影2311的评分...\n",
      "预测出用户1对物品2311的评分：3.56720\n",
      "(1, 2311, 3.57)\n",
      "开始预测用户1对电影2312的评分...\n",
      "预测出用户1对物品2312的评分：3.69656\n",
      "(1, 2312, 3.7)\n",
      "开始预测用户1对电影2313的评分...\n",
      "预测出用户1对物品2313的评分：4.06765\n",
      "(1, 2313, 4.07)\n",
      "开始预测用户1对电影2318的评分...\n",
      "预测出用户1对物品2318的评分：3.95327\n",
      "(1, 2318, 3.95)\n",
      "开始预测用户1对电影2321的评分...\n",
      "预测出用户1对物品2321的评分：3.50109\n",
      "(1, 2321, 3.5)\n",
      "开始预测用户1对电影2324的评分...\n",
      "预测出用户1对物品2324的评分：4.27716\n",
      "(1, 2324, 4.28)\n",
      "开始预测用户1对电影2325的评分...\n",
      "预测出用户1对物品2325的评分：3.48701\n",
      "(1, 2325, 3.49)\n",
      "开始预测用户1对电影2334的评分...\n",
      "预测出用户1对物品2334的评分：2.54253\n",
      "(1, 2334, 2.54)\n",
      "开始预测用户1对电影2335的评分...\n",
      "预测出用户1对物品2335的评分：3.25395\n",
      "(1, 2335, 3.25)\n",
      "开始预测用户1对电影2336的评分...\n",
      "预测出用户1对物品2336的评分：3.90230\n",
      "(1, 2336, 3.9)\n",
      "开始预测用户1对电影2340的评分...\n",
      "预测出用户1对物品2340的评分：2.81462\n",
      "(1, 2340, 2.81)\n",
      "开始预测用户1对电影2346的评分...\n",
      "预测出用户1对物品2346的评分：3.05286\n",
      "(1, 2346, 3.05)\n",
      "开始预测用户1对电影76077的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品76077的评分：3.23402\n",
      "(1, 76077, 3.23)\n",
      "开始预测用户1对电影2352的评分...\n",
      "预测出用户1对物品2352的评分：3.86738\n",
      "(1, 2352, 3.87)\n",
      "开始预测用户1对电影2355的评分...\n",
      "预测出用户1对物品2355的评分：3.51507\n",
      "(1, 2355, 3.52)\n",
      "开始预测用户1对电影2359的评分...\n",
      "预测出用户1对物品2359的评分：3.78306\n",
      "(1, 2359, 3.78)\n",
      "开始预测用户1对电影2360的评分...\n",
      "预测出用户1对物品2360的评分：4.11330\n",
      "(1, 2360, 4.11)\n",
      "开始预测用户1对电影76093的评分...\n",
      "预测出用户1对物品76093的评分：3.91321\n",
      "(1, 76093, 3.91)\n",
      "开始预测用户1对电影2367的评分...\n",
      "预测出用户1对物品2367的评分：2.76959\n",
      "(1, 2367, 2.77)\n",
      "开始预测用户1对电影2369的评分...\n",
      "预测出用户1对物品2369的评分：2.54962\n",
      "(1, 2369, 2.55)\n",
      "开始预测用户1对电影2371的评分...\n",
      "预测出用户1对物品2371的评分：3.27568\n",
      "(1, 2371, 3.28)\n",
      "开始预测用户1对电影2375的评分...\n",
      "预测出用户1对物品2375的评分：3.00543\n",
      "(1, 2375, 3.01)\n",
      "开始预测用户1对电影2376的评分...\n",
      "预测出用户1对物品2376的评分：3.14159\n",
      "(1, 2376, 3.14)\n",
      "开始预测用户1对电影2378的评分...\n",
      "预测出用户1对物品2378的评分：3.07432\n",
      "(1, 2378, 3.07)\n",
      "开始预测用户1对电影2379的评分...\n",
      "预测出用户1对物品2379的评分：2.34134\n",
      "(1, 2379, 2.34)\n",
      "开始预测用户1对电影59725的评分...\n",
      "预测出用户1对物品59725的评分：2.80171\n",
      "(1, 59725, 2.8)\n",
      "开始预测用户1对电影2384的评分...\n",
      "预测出用户1对物品2384的评分：2.35183\n",
      "(1, 2384, 2.35)\n",
      "开始预测用户1对电影51540的评分...\n",
      "预测出用户1对物品51540的评分：3.81729\n",
      "(1, 51540, 3.82)\n",
      "开始预测用户1对电影2391的评分...\n",
      "预测出用户1对物品2391的评分：3.62607\n",
      "(1, 2391, 3.63)\n",
      "开始预测用户1对电影2393的评分...\n",
      "预测出用户1对物品2393的评分：2.84845\n",
      "(1, 2393, 2.85)\n",
      "开始预测用户1对电影2394的评分...\n",
      "预测出用户1对物品2394的评分：3.28453\n",
      "(1, 2394, 3.28)\n",
      "开始预测用户1对电影2396的评分...\n",
      "预测出用户1对物品2396的评分：3.93623\n",
      "(1, 2396, 3.94)\n",
      "开始预测用户1对电影2398的评分...\n",
      "预测出用户1对物品2398的评分：3.86904\n",
      "(1, 2398, 3.87)\n",
      "开始预测用户1对电影2402的评分...\n",
      "预测出用户1对物品2402的评分：2.37395\n",
      "(1, 2402, 2.37)\n",
      "开始预测用户1对电影2403的评分...\n",
      "预测出用户1对物品2403的评分：3.49153\n",
      "(1, 2403, 3.49)\n",
      "开始预测用户1对电影2404的评分...\n",
      "预测出用户1对物品2404的评分：1.75737\n",
      "(1, 2404, 1.76)\n",
      "开始预测用户1对电影2405的评分...\n",
      "预测出用户1对物品2405的评分：2.90886\n",
      "(1, 2405, 2.91)\n",
      "开始预测用户1对电影2407的评分...\n",
      "预测出用户1对物品2407的评分：3.22108\n",
      "(1, 2407, 3.22)\n",
      "开始预测用户1对电影2409的评分...\n",
      "预测出用户1对物品2409的评分：3.48861\n",
      "(1, 2409, 3.49)\n",
      "开始预测用户1对电影2410的评分...\n",
      "预测出用户1对物品2410的评分：2.91202\n",
      "(1, 2410, 2.91)\n",
      "开始预测用户1对电影2411的评分...\n",
      "预测出用户1对物品2411的评分：2.73614\n",
      "(1, 2411, 2.74)\n",
      "开始预测用户1对电影2412的评分...\n",
      "预测出用户1对物品2412的评分：1.96397\n",
      "(1, 2412, 1.96)\n",
      "开始预测用户1对电影2413的评分...\n",
      "预测出用户1对物品2413的评分：3.39978\n",
      "(1, 2413, 3.4)\n",
      "开始预测用户1对电影2416的评分...\n",
      "预测出用户1对物品2416的评分：2.97844\n",
      "(1, 2416, 2.98)\n",
      "开始预测用户1对电影2420的评分...\n",
      "预测出用户1对物品2420的评分：3.65805\n",
      "(1, 2420, 3.66)\n",
      "开始预测用户1对电影2421的评分...\n",
      "预测出用户1对物品2421的评分：2.83336\n",
      "(1, 2421, 2.83)\n",
      "开始预测用户1对电影2422的评分...\n",
      "预测出用户1对物品2422的评分：1.73154\n",
      "(1, 2422, 1.73)\n",
      "开始预测用户1对电影2423的评分...\n",
      "预测出用户1对物品2423的评分：3.22047\n",
      "(1, 2423, 3.22)\n",
      "开始预测用户1对电影2424的评分...\n",
      "预测出用户1对物品2424的评分：3.17106\n",
      "(1, 2424, 3.17)\n",
      "开始预测用户1对电影2428的评分...\n",
      "预测出用户1对物品2428的评分：2.41715\n",
      "(1, 2428, 2.42)\n",
      "开始预测用户1对电影2431的评分...\n",
      "预测出用户1对物品2431的评分：3.57172\n",
      "(1, 2431, 3.57)\n",
      "开始预测用户1对电影2433的评分...\n",
      "预测出用户1对物品2433的评分：2.97969\n",
      "(1, 2433, 2.98)\n",
      "开始预测用户1对电影108932的评分...\n",
      "预测出用户1对物品108932的评分：4.01679\n",
      "(1, 108932, 4.02)\n",
      "开始预测用户1对电影59784的评分...\n",
      "预测出用户1对物品59784的评分：3.67445\n",
      "(1, 59784, 3.67)\n",
      "开始预测用户1对电影2447的评分...\n",
      "预测出用户1对物品2447的评分：2.93955\n",
      "(1, 2447, 2.94)\n",
      "开始预测用户1对电影76175的评分...\n",
      "预测出用户1对物品76175的评分：2.49892\n",
      "(1, 76175, 2.5)\n",
      "开始预测用户1对电影2454的评分...\n",
      "预测出用户1对物品2454的评分：3.19982\n",
      "(1, 2454, 3.2)\n",
      "开始预测用户1对电影2455的评分...\n",
      "预测出用户1对物品2455的评分：3.36158\n",
      "(1, 2455, 3.36)\n",
      "开始预测用户1对电影84374的评分...\n",
      "预测出用户1对物品84374的评分：3.28970\n",
      "(1, 84374, 3.29)\n",
      "开始预测用户1对电影2463的评分...\n",
      "预测出用户1对物品2463的评分：3.32424\n",
      "(1, 2463, 3.32)\n",
      "开始预测用户1对电影2467的评分...\n",
      "预测出用户1对物品2467的评分：3.79360\n",
      "(1, 2467, 3.79)\n",
      "开始预测用户1对电影2468的评分...\n",
      "预测出用户1对物品2468的评分：2.21216\n",
      "(1, 2468, 2.21)\n",
      "开始预测用户1对电影2471的评分...\n",
      "预测出用户1对物品2471的评分：2.06489\n",
      "(1, 2471, 2.06)\n",
      "开始预测用户1对电影2474的评分...\n",
      "预测出用户1对物品2474的评分：3.63442\n",
      "(1, 2474, 3.63)\n",
      "开始预测用户1对电影2476的评分...\n",
      "预测出用户1对物品2476的评分：3.80497\n",
      "(1, 2476, 3.8)\n",
      "开始预测用户1对电影2485的评分...\n",
      "预测出用户1对物品2485的评分：2.76269\n",
      "(1, 2485, 2.76)\n",
      "开始预测用户1对电影117176的评分...\n",
      "预测出用户1对物品117176的评分：3.82243\n",
      "(1, 117176, 3.82)\n",
      "开始预测用户1对电影2490的评分...\n",
      "预测出用户1对物品2490的评分：3.14133\n",
      "(1, 2490, 3.14)\n",
      "开始预测用户1对电影2496的评分...\n",
      "预测出用户1对物品2496的评分：2.58896\n",
      "(1, 2496, 2.59)\n",
      "开始预测用户1对电影2501的评分...\n",
      "预测出用户1对物品2501的评分：3.80182\n",
      "(1, 2501, 3.8)\n",
      "开始预测用户1对电影2505的评分...\n",
      "预测出用户1对物品2505的评分：2.90744\n",
      "(1, 2505, 2.91)\n",
      "开始预测用户1对电影51662的评分...\n",
      "预测出用户1对物品51662的评分：3.70023\n",
      "(1, 51662, 3.7)\n",
      "开始预测用户1对电影76251的评分...\n",
      "预测出用户1对物品76251的评分：3.75720\n",
      "(1, 76251, 3.76)\n",
      "开始预测用户1对电影2527的评分...\n",
      "预测出用户1对物品2527的评分：3.35399\n",
      "(1, 2527, 3.35)\n",
      "开始预测用户1对电影2530的评分...\n",
      "预测出用户1对物品2530的评分：2.68821\n",
      "(1, 2530, 2.69)\n",
      "开始预测用户1对电影2532的评分...\n",
      "预测出用户1对物品2532的评分：2.72909\n",
      "(1, 2532, 2.73)\n",
      "开始预测用户1对电影2533的评分...\n",
      "预测出用户1对物品2533的评分：2.50079\n",
      "(1, 2533, 2.5)\n",
      "开始预测用户1对电影2539的评分...\n",
      "预测出用户1对物品2539的评分：3.19365\n",
      "(1, 2539, 3.19)\n",
      "开始预测用户1对电影2541的评分...\n",
      "预测出用户1对物品2541的评分：2.77916\n",
      "(1, 2541, 2.78)\n",
      "开始预测用户1对电影59900的评分...\n",
      "预测出用户1对物品59900的评分：2.75129\n",
      "(1, 59900, 2.75)\n",
      "开始预测用户1对电影2565的评分...\n",
      "预测出用户1对物品2565的评分：4.05482\n",
      "(1, 2565, 4.05)\n",
      "开始预测用户1对电影76293的评分...\n",
      "预测出用户1对物品76293的评分：3.30036\n",
      "(1, 76293, 3.3)\n",
      "开始预测用户1对电影2567的评分...\n",
      "预测出用户1对物品2567的评分：3.19180\n",
      "(1, 2567, 3.19)\n",
      "开始预测用户1对电影2572的评分...\n",
      "预测出用户1对物品2572的评分：3.19300\n",
      "(1, 2572, 3.19)\n",
      "开始预测用户1对电影2581的评分...\n",
      "预测出用户1对物品2581的评分：2.77120\n",
      "(1, 2581, 2.77)\n",
      "开始预测用户1对电影2583的评分...\n",
      "预测出用户1对物品2583的评分：3.84623\n",
      "(1, 2583, 3.85)\n",
      "开始预测用户1对电影158238的评分...\n",
      "预测出用户1对物品158238的评分：4.06649\n",
      "(1, 158238, 4.07)\n",
      "开始预测用户1对电影2598的评分...\n",
      "预测出用户1对物品2598的评分：2.68251\n",
      "(1, 2598, 2.68)\n",
      "开始预测用户1对电影2599的评分...\n",
      "预测出用户1对物品2599的评分：3.88865\n",
      "(1, 2599, 3.89)\n",
      "开始预测用户1对电影2600的评分...\n",
      "预测出用户1对物品2600的评分：3.86072\n",
      "(1, 2600, 3.86)\n",
      "开始预测用户1对电影2605的评分...\n",
      "预测出用户1对物品2605的评分：2.61310\n",
      "(1, 2605, 2.61)\n",
      "开始预测用户1对电影2606的评分...\n",
      "预测出用户1对物品2606的评分：2.41780\n",
      "(1, 2606, 2.42)\n",
      "开始预测用户1对电影68157的评分...\n",
      "预测出用户1对物品68157的评分：4.12631\n",
      "(1, 68157, 4.13)\n",
      "开始预测用户1对电影2622的评分...\n",
      "预测出用户1对物品2622的评分：3.35758\n",
      "(1, 2622, 3.36)\n",
      "开始预测用户1对电影2642的评分...\n",
      "预测出用户1对物品2642的评分：2.22562\n",
      "(1, 2642, 2.23)\n",
      "开始预测用户1对电影2643的评分...\n",
      "预测出用户1对物品2643的评分：1.61105\n",
      "(1, 2643, 1.61)\n",
      "开始预测用户1对电影2662的评分...\n",
      "预测出用户1对物品2662的评分：3.36226\n",
      "(1, 2662, 3.36)\n",
      "开始预测用户1对电影2664的评分...\n",
      "预测出用户1对物品2664的评分：3.66094\n",
      "(1, 2664, 3.66)\n",
      "开始预测用户1对电影2671的评分...\n",
      "预测出用户1对物品2671的评分：3.38880\n",
      "(1, 2671, 3.39)\n",
      "开始预测用户1对电影2672的评分...\n",
      "预测出用户1对物品2672的评分：3.08640\n",
      "(1, 2672, 3.09)\n",
      "开始预测用户1对电影2683的评分...\n",
      "预测出用户1对物品2683的评分：3.33981\n",
      "(1, 2683, 3.34)\n",
      "开始预测用户1对电影2686的评分...\n",
      "预测出用户1对物品2686的评分：3.88548\n",
      "(1, 2686, 3.89)\n",
      "开始预测用户1对电影2687的评分...\n",
      "预测出用户1对物品2687的评分：3.64487\n",
      "(1, 2687, 3.64)\n",
      "开始预测用户1对电影2688的评分...\n",
      "预测出用户1对物品2688的评分：2.86547\n",
      "(1, 2688, 2.87)\n",
      "开始预测用户1对电影166528的评分...\n",
      "预测出用户1对物品166528的评分：4.06501\n",
      "(1, 166528, 4.07)\n",
      "开始预测用户1对电影2694的评分...\n",
      "预测出用户1对物品2694的评分：3.25151\n",
      "(1, 2694, 3.25)\n",
      "开始预测用户1对电影60040的评分...\n",
      "预测出用户1对物品60040的评分：2.98528\n",
      "(1, 60040, 2.99)\n",
      "开始预测用户1对电影2699的评分...\n",
      "预测出用户1对物品2699的评分：2.64381\n",
      "(1, 2699, 2.64)\n",
      "开始预测用户1对电影2701的评分...\n",
      "预测出用户1对物品2701的评分：2.17892\n",
      "(1, 2701, 2.18)\n",
      "开始预测用户1对电影2702的评分...\n",
      "预测出用户1对物品2702的评分：3.57835\n",
      "(1, 2702, 3.58)\n",
      "开始预测用户1对电影68237的评分...\n",
      "预测出用户1对物品68237的评分：3.50938\n",
      "(1, 68237, 3.51)\n",
      "开始预测用户1对电影2706的评分...\n",
      "预测出用户1对物品2706的评分：3.35711\n",
      "(1, 2706, 3.36)\n",
      "开始预测用户1对电影2707的评分...\n",
      "预测出用户1对物品2707的评分：2.99780\n",
      "(1, 2707, 3.0)\n",
      "开始预测用户1对电影2710的评分...\n",
      "预测出用户1对物品2710的评分：2.62078\n",
      "(1, 2710, 2.62)\n",
      "开始预测用户1对电影2712的评分...\n",
      "预测出用户1对物品2712的评分：3.34731\n",
      "(1, 2712, 3.35)\n",
      "开始预测用户1对电影2713的评分...\n",
      "预测出用户1对物品2713的评分：2.49964\n",
      "(1, 2713, 2.5)\n",
      "开始预测用户1对电影2717的评分...\n",
      "预测出用户1对物品2717的评分：2.90315\n",
      "(1, 2717, 2.9)\n",
      "开始预测用户1对电影2719的评分...\n",
      "预测出用户1对物品2719的评分：2.30005\n",
      "(1, 2719, 2.3)\n",
      "开始预测用户1对电影2720的评分...\n",
      "预测出用户1对物品2720的评分：2.04611\n",
      "(1, 2720, 2.05)\n",
      "开始预测用户1对电影2722的评分...\n",
      "预测出用户1对物品2722的评分：2.53176\n",
      "(1, 2722, 2.53)\n",
      "开始预测用户1对电影2723的评分...\n",
      "预测出用户1对物品2723的评分：3.14525\n",
      "(1, 2723, 3.15)\n",
      "开始预测用户1对电影2724的评分...\n",
      "预测出用户1对物品2724的评分：2.60440\n",
      "(1, 2724, 2.6)\n",
      "开始预测用户1对电影60069的评分...\n",
      "预测出用户1对物品60069的评分：4.06110\n",
      "(1, 60069, 4.06)\n",
      "开始预测用户1对电影2728的评分...\n",
      "预测出用户1对物品2728的评分：3.74533\n",
      "(1, 2728, 3.75)\n",
      "开始预测用户1对电影60072的评分...\n",
      "预测出用户1对物品60072的评分：2.97981\n",
      "(1, 60072, 2.98)\n",
      "开始预测用户1对电影60074的评分...\n",
      "预测出用户1对物品60074的评分：2.97751\n",
      "(1, 60074, 2.98)\n",
      "开始预测用户1对电影2731的评分...\n",
      "预测出用户1对物品2731的评分：3.67993\n",
      "(1, 2731, 3.68)\n",
      "开始预测用户1对电影2735的评分...\n",
      "预测出用户1对物品2735的评分：2.71867\n",
      "(1, 2735, 2.72)\n",
      "开始预测用户1对电影2739的评分...\n",
      "预测出用户1对物品2739的评分：4.08353\n",
      "(1, 2739, 4.08)\n",
      "开始预测用户1对电影2746的评分...\n",
      "预测出用户1对物品2746的评分：3.37832\n",
      "(1, 2746, 3.38)\n",
      "开始预测用户1对电影2762的评分...\n",
      "预测出用户1对物品2762的评分：3.93617\n",
      "(1, 2762, 3.94)\n",
      "开始预测用户1对电影2763的评分...\n",
      "预测出用户1对物品2763的评分：3.47593\n",
      "(1, 2763, 3.48)\n",
      "开始预测用户1对电影2770的评分...\n",
      "预测出用户1对物品2770的评分：3.04567\n",
      "(1, 2770, 3.05)\n",
      "开始预测用户1对电影2779的评分...\n",
      "预测出用户1对物品2779的评分：3.27994\n",
      "(1, 2779, 3.28)\n",
      "开始预测用户1对电影60126的评分...\n",
      "预测出用户1对物品60126的评分：3.19458\n",
      "(1, 60126, 3.19)\n",
      "开始预测用户1对电影51935的评分...\n",
      "预测出用户1对物品51935的评分：3.95061\n",
      "(1, 51935, 3.95)\n",
      "开始预测用户1对电影68319的评分...\n",
      "预测出用户1对物品68319的评分：2.58311\n",
      "(1, 68319, 2.58)\n",
      "开始预测用户1对电影2788的评分...\n",
      "预测出用户1对物品2788的评分：3.97865\n",
      "(1, 2788, 3.98)\n",
      "开始预测用户1对电影2791的评分...\n",
      "预测出用户1对物品2791的评分：3.75979\n",
      "(1, 2791, 3.76)\n",
      "开始预测用户1对电影2792的评分...\n",
      "预测出用户1对物品2792的评分：3.04623\n",
      "(1, 2792, 3.05)\n",
      "开始预测用户1对电影2794的评分...\n",
      "预测出用户1对物品2794的评分：2.63287\n",
      "(1, 2794, 2.63)\n",
      "开始预测用户1对电影2795的评分...\n",
      "预测出用户1对物品2795的评分：3.58630\n",
      "(1, 2795, 3.59)\n",
      "开始预测用户1对电影2796的评分...\n",
      "预测出用户1对物品2796的评分：2.79609\n",
      "(1, 2796, 2.8)\n",
      "开始预测用户1对电影2798的评分...\n",
      "预测出用户1对物品2798的评分：1.39405\n",
      "(1, 2798, 1.39)\n",
      "开始预测用户1对电影2802的评分...\n",
      "预测出用户1对物品2802的评分：3.04667\n",
      "(1, 2802, 3.05)\n",
      "开始预测用户1对电影2803的评分...\n",
      "预测出用户1对物品2803的评分：2.88192\n",
      "(1, 2803, 2.88)\n",
      "开始预测用户1对电影2804的评分...\n",
      "预测出用户1对物品2804的评分：4.09328\n",
      "(1, 2804, 4.09)\n",
      "开始预测用户1对电影2805的评分...\n",
      "预测出用户1对物品2805的评分：2.86147\n",
      "(1, 2805, 2.86)\n",
      "开始预测用户1对电影2808的评分...\n",
      "预测出用户1对物品2808的评分：1.97345\n",
      "(1, 2808, 1.97)\n",
      "开始预测用户1对电影2819的评分...\n",
      "预测出用户1对物品2819的评分：3.94241\n",
      "(1, 2819, 3.94)\n",
      "开始预测用户1对电影2822的评分...\n",
      "预测出用户1对物品2822的评分：2.66164\n",
      "(1, 2822, 2.66)\n",
      "开始预测用户1对电影68358的评分...\n",
      "预测出用户1对物品68358的评分：3.91363\n",
      "(1, 68358, 3.91)\n",
      "开始预测用户1对电影2827的评分...\n",
      "预测出用户1对物品2827的评分：1.99567\n",
      "(1, 2827, 2.0)\n",
      "开始预测用户1对电影2840的评分...\n",
      "预测出用户1对物品2840的评分：2.89749\n",
      "(1, 2840, 2.9)\n",
      "开始预测用户1对电影2841的评分...\n",
      "预测出用户1对物品2841的评分：3.48182\n",
      "(1, 2841, 3.48)\n",
      "开始预测用户1对电影117529的评分...\n",
      "预测出用户1对物品117529的评分：3.45254\n",
      "(1, 117529, 3.45)\n",
      "开始预测用户1对电影84772的评分...\n",
      "预测出用户1对物品84772的评分：3.29076\n",
      "(1, 84772, 3.29)\n",
      "开始预测用户1对电影2857的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品2857的评分：3.33812\n",
      "(1, 2857, 3.34)\n",
      "开始预测用户1对电影2863的评分...\n",
      "预测出用户1对物品2863的评分：3.59149\n",
      "(1, 2863, 3.59)\n",
      "开始预测用户1对电影2867的评分...\n",
      "预测出用户1对物品2867的评分：3.37655\n",
      "(1, 2867, 3.38)\n",
      "开始预测用户1对电影2871的评分...\n",
      "预测出用户1对物品2871的评分：3.85261\n",
      "(1, 2871, 3.85)\n",
      "开始预测用户1对电影109374的评分...\n",
      "预测出用户1对物品109374的评分：3.66951\n",
      "(1, 109374, 3.67)\n",
      "开始预测用户1对电影2881的评分...\n",
      "预测出用户1对物品2881的评分：2.36780\n",
      "(1, 2881, 2.37)\n",
      "开始预测用户1对电影2890的评分...\n",
      "预测出用户1对物品2890的评分：3.74897\n",
      "(1, 2890, 3.75)\n",
      "开始预测用户1对电影2901的评分...\n",
      "预测出用户1对物品2901的评分：2.46976\n",
      "(1, 2901, 2.47)\n",
      "开始预测用户1对电影117590的评分...\n",
      "预测出用户1对物品117590的评分：3.20946\n",
      "(1, 117590, 3.21)\n",
      "开始预测用户1对电影2908的评分...\n",
      "预测出用户1对物品2908的评分：3.33980\n",
      "(1, 2908, 3.34)\n",
      "开始预测用户1对电影2912的评分...\n",
      "预测出用户1对物品2912的评分：3.85297\n",
      "(1, 2912, 3.85)\n",
      "开始预测用户1对电影2915的评分...\n",
      "预测出用户1对物品2915的评分：3.50869\n",
      "(1, 2915, 3.51)\n",
      "开始预测用户1对电影2918的评分...\n",
      "预测出用户1对物品2918的评分：3.77226\n",
      "(1, 2918, 3.77)\n",
      "开始预测用户1对电影2921的评分...\n",
      "预测出用户1对物品2921的评分：4.33268\n",
      "(1, 2921, 4.33)\n",
      "开始预测用户1对电影2926的评分...\n",
      "预测出用户1对物品2926的评分：3.42649\n",
      "(1, 2926, 3.43)\n",
      "开始预测用户1对电影2942的评分...\n",
      "预测出用户1对物品2942的评分：2.77272\n",
      "(1, 2942, 2.77)\n",
      "开始预测用户1对电影2950的评分...\n",
      "预测出用户1对物品2950的评分：2.50330\n",
      "(1, 2950, 2.5)\n",
      "开始预测用户1对电影2951的评分...\n",
      "预测出用户1对物品2951的评分：4.20416\n",
      "(1, 2951, 4.2)\n",
      "开始预测用户1对电影2952的评分...\n",
      "预测出用户1对物品2952的评分：3.87417\n",
      "(1, 2952, 3.87)\n",
      "开始预测用户1对电影2953的评分...\n",
      "预测出用户1对物品2953的评分：2.22788\n",
      "(1, 2953, 2.23)\n",
      "开始预测用户1对电影2966的评分...\n",
      "预测出用户1对物品2966的评分：4.15195\n",
      "(1, 2966, 4.15)\n",
      "开始预测用户1对电影2968的评分...\n",
      "预测出用户1对物品2968的评分：3.68668\n",
      "(1, 2968, 3.69)\n",
      "开始预测用户1对电影43928的评分...\n",
      "预测出用户1对物品43928的评分：1.79087\n",
      "(1, 43928, 1.79)\n",
      "开始预测用户1对电影2973的评分...\n",
      "预测出用户1对物品2973的评分：3.97409\n",
      "(1, 2973, 3.97)\n",
      "开始预测用户1对电影2986的评分...\n",
      "预测出用户1对物品2986的评分：2.45686\n",
      "(1, 2986, 2.46)\n",
      "开始预测用户1对电影2989的评分...\n",
      "预测出用户1对物品2989的评分：3.58081\n",
      "(1, 2989, 3.58)\n",
      "开始预测用户1对电影2990的评分...\n",
      "预测出用户1对物品2990的评分：3.12868\n",
      "(1, 2990, 3.13)\n",
      "开始预测用户1对电影109487的评分...\n",
      "预测出用户1对物品109487的评分：4.35743\n",
      "(1, 109487, 4.36)\n",
      "开始预测用户1对电影2995的评分...\n",
      "预测出用户1对物品2995的评分：2.41557\n",
      "(1, 2995, 2.42)\n",
      "开始预测用户1对电影3000的评分...\n",
      "预测出用户1对物品3000的评分：4.28614\n",
      "(1, 3000, 4.29)\n",
      "开始预测用户1对电影3004的评分...\n",
      "预测出用户1对物品3004的评分：2.34044\n",
      "(1, 3004, 2.34)\n",
      "开始预测用户1对电影3005的评分...\n",
      "预测出用户1对物品3005的评分：2.38250\n",
      "(1, 3005, 2.38)\n",
      "开始预测用户1对电影3006的评分...\n",
      "预测出用户1对物品3006的评分：3.67397\n",
      "(1, 3006, 3.67)\n",
      "开始预测用户1对电影3016的评分...\n",
      "预测出用户1对物品3016的评分：3.06715\n",
      "(1, 3016, 3.07)\n",
      "开始预测用户1对电影68554的评分...\n",
      "预测出用户1对物品68554的评分：3.44583\n",
      "(1, 68554, 3.45)\n",
      "开始预测用户1对电影3020的评分...\n",
      "预测出用户1对物品3020的评分：3.75930\n",
      "(1, 3020, 3.76)\n",
      "开始预测用户1对电影84944的评分...\n",
      "预测出用户1对物品84944的评分：3.78614\n",
      "(1, 84944, 3.79)\n",
      "开始预测用户1对电影3030的评分...\n",
      "预测出用户1对物品3030的评分：4.63447\n",
      "(1, 3030, 4.63)\n",
      "开始预测用户1对电影84954的评分...\n",
      "预测出用户1对物品84954的评分：3.25135\n",
      "(1, 84954, 3.25)\n",
      "开始预测用户1对电影3035的评分...\n",
      "预测出用户1对物品3035的评分：3.68717\n",
      "(1, 3035, 3.69)\n",
      "开始预测用户1对电影27611的评分...\n",
      "预测出用户1对物品27611的评分：3.98184\n",
      "(1, 27611, 3.98)\n",
      "开始预测用户1对电影3037的评分...\n",
      "预测出用户1对物品3037的评分：4.09352\n",
      "(1, 3037, 4.09)\n",
      "开始预测用户1对电影3039的评分...\n",
      "预测出用户1对物品3039的评分：3.67376\n",
      "(1, 3039, 3.67)\n",
      "开始预测用户1对电影3044的评分...\n",
      "预测出用户1对物品3044的评分：3.55656\n",
      "(1, 3044, 3.56)\n",
      "开始预测用户1对电影60397的评分...\n",
      "预测出用户1对物品60397的评分：2.54395\n",
      "(1, 60397, 2.54)\n",
      "开始预测用户1对电影134130的评分...\n",
      "预测出用户1对物品134130的评分：4.11030\n",
      "(1, 134130, 4.11)\n",
      "开始预测用户1对电影3060的评分...\n",
      "预测出用户1对物品3060的评分：4.03962\n",
      "(1, 3060, 4.04)\n",
      "开始预测用户1对电影44022的评分...\n",
      "预测出用户1对物品44022的评分：3.08236\n",
      "(1, 44022, 3.08)\n",
      "开始预测用户1对电影35836的评分...\n",
      "预测出用户1对物品35836的评分：3.44223\n",
      "(1, 35836, 3.44)\n",
      "开始预测用户1对电影3070的评分...\n",
      "预测出用户1对物品3070的评分：3.72345\n",
      "(1, 3070, 3.72)\n",
      "开始预测用户1对电影3072的评分...\n",
      "预测出用户1对物品3072的评分：3.44787\n",
      "(1, 3072, 3.45)\n",
      "开始预测用户1对电影3081的评分...\n",
      "预测出用户1对物品3081的评分：3.44801\n",
      "(1, 3081, 3.45)\n",
      "开始预测用户1对电影3082的评分...\n",
      "预测出用户1对物品3082的评分：3.14013\n",
      "(1, 3082, 3.14)\n",
      "开始预测用户1对电影3083的评分...\n",
      "预测出用户1对物品3083的评分：4.19020\n",
      "(1, 3083, 4.19)\n",
      "开始预测用户1对电影27660的评分...\n",
      "预测出用户1对物品27660的评分：3.96184\n",
      "(1, 27660, 3.96)\n",
      "开始预测用户1对电影3087的评分...\n",
      "预测出用户1对物品3087的评分：3.34555\n",
      "(1, 3087, 3.35)\n",
      "开始预测用户1对电影3088的评分...\n",
      "预测出用户1对物品3088的评分：3.88424\n",
      "(1, 3088, 3.88)\n",
      "开始预测用户1对电影3089的评分...\n",
      "预测出用户1对物品3089的评分：3.90705\n",
      "(1, 3089, 3.91)\n",
      "开始预测用户1对电影52245的评分...\n",
      "预测出用户1对物品52245的评分：3.16350\n",
      "(1, 52245, 3.16)\n",
      "开始预测用户1对电影3098的评分...\n",
      "预测出用户1对物品3098的评分：3.67308\n",
      "(1, 3098, 3.67)\n",
      "开始预测用户1对电影3100的评分...\n",
      "预测出用户1对物品3100的评分：3.96136\n",
      "(1, 3100, 3.96)\n",
      "开始预测用户1对电影3101的评分...\n",
      "预测出用户1对物品3101的评分：3.12597\n",
      "(1, 3101, 3.13)\n",
      "开始预测用户1对电影3104的评分...\n",
      "预测出用户1对物品3104的评分：3.64431\n",
      "(1, 3104, 3.64)\n",
      "开始预测用户1对电影3105的评分...\n",
      "预测出用户1对物品3105的评分：3.71628\n",
      "(1, 3105, 3.72)\n",
      "开始预测用户1对电影3107的评分...\n",
      "预测出用户1对物品3107的评分：3.02094\n",
      "(1, 3107, 3.02)\n",
      "开始预测用户1对电影3108的评分...\n",
      "预测出用户1对物品3108的评分：3.70566\n",
      "(1, 3108, 3.71)\n",
      "开始预测用户1对电影3113的评分...\n",
      "预测出用户1对物品3113的评分：2.33649\n",
      "(1, 3113, 2.34)\n",
      "开始预测用户1对电影3114的评分...\n",
      "预测出用户1对物品3114的评分：3.71574\n",
      "(1, 3114, 3.72)\n",
      "开始预测用户1对电影52281的评分...\n",
      "预测出用户1对物品52281的评分：3.34466\n",
      "(1, 52281, 3.34)\n",
      "开始预测用户1对电影27706的评分...\n",
      "预测出用户1对物品27706的评分：3.02986\n",
      "(1, 27706, 3.03)\n",
      "开始预测用户1对电影52287的评分...\n",
      "预测出用户1对物品52287的评分：3.69142\n",
      "(1, 52287, 3.69)\n",
      "开始预测用户1对电影3146的评分...\n",
      "预测出用户1对物品3146的评分：2.16819\n",
      "(1, 3146, 2.17)\n",
      "开始预测用户1对电影3148的评分...\n",
      "预测出用户1对物品3148的评分：3.76197\n",
      "(1, 3148, 3.76)\n",
      "开始预测用户1对电影3156的评分...\n",
      "预测出用户1对物品3156的评分：2.64453\n",
      "(1, 3156, 2.64)\n",
      "开始预测用户1对电影3157的评分...\n",
      "预测出用户1对物品3157的评分：2.64894\n",
      "(1, 3157, 2.65)\n",
      "开始预测用户1对电影3159的评分...\n",
      "预测出用户1对物品3159的评分：3.97081\n",
      "(1, 3159, 3.97)\n",
      "开始预测用户1对电影3160的评分...\n",
      "预测出用户1对物品3160的评分：3.75279\n",
      "(1, 3160, 3.75)\n",
      "开始预测用户1对电影3173的评分...\n",
      "预测出用户1对物品3173的评分：2.81356\n",
      "(1, 3173, 2.81)\n",
      "开始预测用户1对电影3174的评分...\n",
      "预测出用户1对物品3174的评分：3.49329\n",
      "(1, 3174, 3.49)\n",
      "开始预测用户1对电影3175的评分...\n",
      "预测出用户1对物品3175的评分：3.52824\n",
      "(1, 3175, 3.53)\n",
      "开始预测用户1对电影52328的评分...\n",
      "预测出用户1对物品52328的评分：3.41294\n",
      "(1, 52328, 3.41)\n",
      "开始预测用户1对电影3178的评分...\n",
      "预测出用户1对物品3178的评分：3.59896\n",
      "(1, 3178, 3.6)\n",
      "开始预测用户1对电影3186的评分...\n",
      "预测出用户1对物品3186的评分：3.29664\n",
      "(1, 3186, 3.3)\n",
      "开始预测用户1对电影3189的评分...\n",
      "预测出用户1对物品3189的评分：3.49639\n",
      "(1, 3189, 3.5)\n",
      "开始预测用户1对电影27773的评分...\n",
      "预测出用户1对物品27773的评分：4.23411\n",
      "(1, 27773, 4.23)\n",
      "开始预测用户1对电影3198的评分...\n",
      "预测出用户1对物品3198的评分：3.93723\n",
      "(1, 3198, 3.94)\n",
      "开始预测用户1对电影3203的评分...\n",
      "预测出用户1对物品3203的评分：2.39001\n",
      "(1, 3203, 2.39)\n",
      "开始预测用户1对电影3210的评分...\n",
      "预测出用户1对物品3210的评分：3.48677\n",
      "(1, 3210, 3.49)\n",
      "开始预测用户1对电影3213的评分...\n",
      "预测出用户1对物品3213的评分：4.02104\n",
      "(1, 3213, 4.02)\n",
      "开始预测用户1对电影93326的评分...\n",
      "预测出用户1对物品93326的评分：2.79275\n",
      "(1, 93326, 2.79)\n",
      "开始预测用户1对电影3219的评分...\n",
      "预测出用户1对物品3219的评分：2.75210\n",
      "(1, 3219, 2.75)\n",
      "开始预测用户1对电影142488的评分...\n",
      "预测出用户1对物品142488的评分：4.46748\n",
      "(1, 142488, 4.47)\n",
      "开始预测用户1对电影27801的评分...\n",
      "预测出用户1对物品27801的评分：3.85296\n",
      "(1, 27801, 3.85)\n",
      "开始预测用户1对电影44191的评分...\n",
      "预测出用户1对物品44191的评分：3.95924\n",
      "(1, 44191, 3.96)\n",
      "开始预测用户1对电影27808的评分...\n",
      "预测出用户1对物品27808的评分：3.74167\n",
      "(1, 27808, 3.74)\n",
      "开始预测用户1对电影44195的评分...\n",
      "预测出用户1对物品44195的评分：4.09854\n",
      "(1, 44195, 4.1)\n",
      "开始预测用户1对电影27815的评分...\n",
      "预测出用户1对物品27815的评分：4.12389\n",
      "(1, 27815, 4.12)\n",
      "开始预测用户1对电影44199的评分...\n",
      "预测出用户1对物品44199的评分：3.63248\n",
      "(1, 44199, 3.63)\n",
      "开始预测用户1对电影3244的评分...\n",
      "预测出用户1对物品3244的评分：3.81903\n",
      "(1, 3244, 3.82)\n",
      "开始预测用户1对电影3246的评分...\n",
      "预测出用户1对物品3246的评分：4.49520\n",
      "(1, 3246, 4.5)\n",
      "开始预测用户1对电影3248的评分...\n",
      "预测出用户1对物品3248的评分：1.76511\n",
      "(1, 3248, 1.77)\n",
      "开始预测用户1对电影93363的评分...\n",
      "预测出用户1对物品93363的评分：2.96680\n",
      "(1, 93363, 2.97)\n",
      "开始预测用户1对电影3252的评分...\n",
      "预测出用户1对物品3252的评分：3.83432\n",
      "(1, 3252, 3.83)\n",
      "开始预测用户1对电影3254的评分...\n",
      "预测出用户1对物品3254的评分：3.28314\n",
      "(1, 3254, 3.28)\n",
      "开始预测用户1对电影27831的评分...\n",
      "预测出用户1对物品27831的评分：4.00142\n",
      "(1, 27831, 4.0)\n",
      "开始预测用户1对电影68791的评分...\n",
      "预测出用户1对物品68791的评分：2.98031\n",
      "(1, 68791, 2.98)\n",
      "开始预测用户1对电影3257的评分...\n",
      "预测出用户1对物品3257的评分：2.55799\n",
      "(1, 3257, 2.56)\n",
      "开始预测用户1对电影3258的评分...\n",
      "预测出用户1对物品3258的评分：2.87938\n",
      "(1, 3258, 2.88)\n",
      "开始预测用户1对电影3259的评分...\n",
      "预测出用户1对物品3259的评分：2.97971\n",
      "(1, 3259, 2.98)\n",
      "开始预测用户1对电影3260的评分...\n",
      "预测出用户1对物品3260的评分：3.71081\n",
      "(1, 3260, 3.71)\n",
      "开始预测用户1对电影3261的评分...\n",
      "预测出用户1对物品3261的评分：3.37067\n",
      "(1, 3261, 3.37)\n",
      "开始预测用户1对电影3262的评分...\n",
      "预测出用户1对物品3262的评分：3.23842\n",
      "(1, 3262, 3.24)\n",
      "开始预测用户1对电影3263的评分...\n",
      "预测出用户1对物品3263的评分：3.14864\n",
      "(1, 3263, 3.15)\n",
      "开始预测用户1对电影3264的评分...\n",
      "预测出用户1对物品3264的评分：2.17108\n",
      "(1, 3264, 2.17)\n",
      "开始预测用户1对电影3256的评分...\n",
      "预测出用户1对物品3256的评分：3.51680\n",
      "(1, 3256, 3.52)\n",
      "开始预测用户1对电影3267的评分...\n",
      "预测出用户1对物品3267的评分：3.46292\n",
      "(1, 3267, 3.46)\n",
      "开始预测用户1对电影3268的评分...\n",
      "预测出用户1对物品3268的评分：1.87646\n",
      "(1, 3268, 1.88)\n",
      "开始预测用户1对电影3269的评分...\n",
      "预测出用户1对物品3269的评分：2.81826\n",
      "(1, 3269, 2.82)\n",
      "开始预测用户1对电影3270的评分...\n",
      "预测出用户1对物品3270的评分：2.54617\n",
      "(1, 3270, 2.55)\n",
      "开始预测用户1对电影3271的评分...\n",
      "预测出用户1对物品3271的评分：3.77058\n",
      "(1, 3271, 3.77)\n",
      "开始预测用户1对电影3274的评分...\n",
      "预测出用户1对物品3274的评分：3.68815\n",
      "(1, 3274, 3.69)\n",
      "开始预测用户1对电影3275的评分...\n",
      "预测出用户1对物品3275的评分：4.33357\n",
      "(1, 3275, 4.33)\n",
      "开始预测用户1对电影52435的评分...\n",
      "预测出用户1对物品52435的评分：3.96916\n",
      "(1, 52435, 3.97)\n",
      "开始预测用户1对电影3285的评分...\n",
      "预测出用户1对物品3285的评分：2.94081\n",
      "(1, 3285, 2.94)\n",
      "开始预测用户1对电影106489的评分...\n",
      "预测出用户1对物品106489的评分：3.85901\n",
      "(1, 106489, 3.86)\n",
      "开始预测用户1对电影134368的评分...\n",
      "预测出用户1对物品134368的评分：3.69650\n",
      "(1, 134368, 3.7)\n",
      "开始预测用户1对电影3298的评分...\n",
      "预测出用户1对物品3298的评分：3.73317\n",
      "(1, 3298, 3.73)\n",
      "开始预测用户1对电影3300的评分...\n",
      "预测出用户1对物品3300的评分：3.50399\n",
      "(1, 3300, 3.5)\n",
      "开始预测用户1对电影3301的评分...\n",
      "预测出用户1对物品3301的评分：3.48430\n",
      "(1, 3301, 3.48)\n",
      "开始预测用户1对电影3307的评分...\n",
      "预测出用户1对物品3307的评分：4.26844\n",
      "(1, 3307, 4.27)\n",
      "开始预测用户1对电影3316的评分...\n",
      "预测出用户1对物品3316的评分：2.30725\n",
      "(1, 3316, 2.31)\n",
      "开始预测用户1对电影3317的评分...\n",
      "预测出用户1对物品3317的评分：3.71817\n",
      "(1, 3317, 3.72)\n",
      "开始预测用户1对电影3328的评分...\n",
      "预测出用户1对物品3328的评分：3.72302\n",
      "(1, 3328, 3.72)\n",
      "开始预测用户1对电影27904的评分...\n",
      "预测出用户1对物品27904的评分：3.78917\n",
      "(1, 27904, 3.79)\n",
      "开始预测用户1对电影60684的评分...\n",
      "预测出用户1对物品60684的评分：4.08251\n",
      "(1, 60684, 4.08)\n",
      "开始预测用户1对电影3354的评分...\n",
      "预测出用户1对物品3354的评分：2.65967\n",
      "(1, 3354, 2.66)\n",
      "开始预测用户1对电影3355的评分...\n",
      "预测出用户1对物品3355的评分：3.12429\n",
      "(1, 3355, 3.12)\n",
      "开始预测用户1对电影3359的评分...\n",
      "预测出用户1对物品3359的评分：4.06036\n",
      "(1, 3359, 4.06)\n",
      "开始预测用户1对电影3360的评分...\n",
      "预测出用户1对物品3360的评分：3.62953\n",
      "(1, 3360, 3.63)\n",
      "开始预测用户1对电影3361的评分...\n",
      "预测出用户1对物品3361的评分：3.60812\n",
      "(1, 3361, 3.61)\n",
      "开始预测用户1对电影3362的评分...\n",
      "预测出用户1对物品3362的评分：3.79283\n",
      "(1, 3362, 3.79)\n",
      "开始预测用户1对电影3363的评分...\n",
      "预测出用户1对物品3363的评分：3.73865\n",
      "(1, 3363, 3.74)\n",
      "开始预测用户1对电影3388的评分...\n",
      "预测出用户1对物品3388的评分：2.48531\n",
      "(1, 3388, 2.49)\n",
      "开始预测用户1对电影3396的评分...\n",
      "预测出用户1对物品3396的评分：3.85425\n",
      "(1, 3396, 3.85)\n",
      "开始预测用户1对电影3397的评分...\n",
      "预测出用户1对物品3397的评分：3.61048\n",
      "(1, 3397, 3.61)\n",
      "开始预测用户1对电影3398的评分...\n",
      "预测出用户1对物品3398的评分：3.39110\n",
      "(1, 3398, 3.39)\n",
      "开始预测用户1对电影93510的评分...\n",
      "预测出用户1对物品93510的评分：3.91889\n",
      "(1, 93510, 3.92)\n",
      "开始预测用户1对电影3408的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品3408的评分：3.42577\n",
      "(1, 3408, 3.43)\n",
      "开始预测用户1对电影3409的评分...\n",
      "预测出用户1对物品3409的评分：2.61315\n",
      "(1, 3409, 2.61)\n",
      "开始预测用户1对电影60756的评分...\n",
      "预测出用户1对物品60756的评分：3.52459\n",
      "(1, 60756, 3.52)\n",
      "开始预测用户1对电影68954的评分...\n",
      "预测出用户1对物品68954的评分：4.07839\n",
      "(1, 68954, 4.08)\n",
      "开始预测用户1对电影3418的评分...\n",
      "预测出用户1对物品3418的评分：3.27448\n",
      "(1, 3418, 3.27)\n",
      "开始预测用户1对电影3421的评分...\n",
      "预测出用户1对物品3421的评分：3.83676\n",
      "(1, 3421, 3.84)\n",
      "开始预测用户1对电影3424的评分...\n",
      "预测出用户1对物品3424的评分：3.75979\n",
      "(1, 3424, 3.76)\n",
      "开始预测用户1对电影3429的评分...\n",
      "预测出用户1对物品3429的评分：4.06909\n",
      "(1, 3429, 4.07)\n",
      "开始预测用户1对电影3435的评分...\n",
      "预测出用户1对物品3435的评分：4.08797\n",
      "(1, 3435, 4.09)\n",
      "开始预测用户1对电影3438的评分...\n",
      "预测出用户1对物品3438的评分：2.99291\n",
      "(1, 3438, 2.99)\n",
      "开始预测用户1对电影159093的评分...\n",
      "预测出用户1对物品159093的评分：4.00497\n",
      "(1, 159093, 4.0)\n",
      "开始预测用户1对电影3451的评分...\n",
      "预测出用户1对物品3451的评分：4.54753\n",
      "(1, 3451, 4.55)\n",
      "开始预测用户1对电影3452的评分...\n",
      "预测出用户1对物品3452的评分：2.95594\n",
      "(1, 3452, 2.96)\n",
      "开始预测用户1对电影52604的评分...\n",
      "预测出用户1对物品52604的评分：4.00457\n",
      "(1, 52604, 4.0)\n",
      "开始预测用户1对电影3461的评分...\n",
      "预测出用户1对物品3461的评分：3.18288\n",
      "(1, 3461, 3.18)\n",
      "开始预测用户1对电影3462的评分...\n",
      "预测出用户1对物品3462的评分：3.93068\n",
      "(1, 3462, 3.93)\n",
      "开始预测用户1对电影3468的评分...\n",
      "预测出用户1对物品3468的评分：4.18749\n",
      "(1, 3468, 4.19)\n",
      "开始预测用户1对电影3471的评分...\n",
      "预测出用户1对物品3471的评分：3.85577\n",
      "(1, 3471, 3.86)\n",
      "开始预测用户1对电影3476的评分...\n",
      "预测出用户1对物品3476的评分：3.65158\n",
      "(1, 3476, 3.65)\n",
      "开始预测用户1对电影3477的评分...\n",
      "预测出用户1对物品3477的评分：3.56658\n",
      "(1, 3477, 3.57)\n",
      "开始预测用户1对电影3481的评分...\n",
      "预测出用户1对物品3481的评分：3.70485\n",
      "(1, 3481, 3.7)\n",
      "开始预测用户1对电影3483的评分...\n",
      "预测出用户1对物品3483的评分：2.74205\n",
      "(1, 3483, 2.74)\n",
      "开始预测用户1对电影85414的评分...\n",
      "预测出用户1对物品85414的评分：3.57141\n",
      "(1, 85414, 3.57)\n",
      "开始预测用户1对电影3499的评分...\n",
      "预测出用户1对物品3499的评分：3.85213\n",
      "(1, 3499, 3.85)\n",
      "开始预测用户1对电影3503的评分...\n",
      "预测出用户1对物品3503的评分：3.87280\n",
      "(1, 3503, 3.87)\n",
      "开始预测用户1对电影3504的评分...\n",
      "预测出用户1对物品3504的评分：3.97380\n",
      "(1, 3504, 3.97)\n",
      "开始预测用户1对电影3507的评分...\n",
      "预测出用户1对物品3507的评分：4.26330\n",
      "(1, 3507, 4.26)\n",
      "开始预测用户1对电影3508的评分...\n",
      "预测出用户1对物品3508的评分：4.28438\n",
      "(1, 3508, 4.28)\n",
      "开始预测用户1对电影3510的评分...\n",
      "预测出用户1对物品3510的评分：3.39737\n",
      "(1, 3510, 3.4)\n",
      "开始预测用户1对电影3526的评分...\n",
      "预测出用户1对物品3526的评分：3.74002\n",
      "(1, 3526, 3.74)\n",
      "开始预测用户1对电影3534的评分...\n",
      "预测出用户1对物品3534的评分：3.24584\n",
      "(1, 3534, 3.25)\n",
      "开始预测用户1对电影3535的评分...\n",
      "预测出用户1对物品3535的评分：3.83677\n",
      "(1, 3535, 3.84)\n",
      "开始预测用户1对电影3536的评分...\n",
      "预测出用户1对物品3536的评分：3.41701\n",
      "(1, 3536, 3.42)\n",
      "开始预测用户1对电影3543的评分...\n",
      "预测出用户1对物品3543的评分：3.89813\n",
      "(1, 3543, 3.9)\n",
      "开始预测用户1对电影3551的评分...\n",
      "预测出用户1对物品3551的评分：3.27629\n",
      "(1, 3551, 3.28)\n",
      "开始预测用户1对电影3552的评分...\n",
      "预测出用户1对物品3552的评分：3.91218\n",
      "(1, 3552, 3.91)\n",
      "开始预测用户1对电影3555的评分...\n",
      "预测出用户1对物品3555的评分：3.41176\n",
      "(1, 3555, 3.41)\n",
      "开始预测用户1对电影3556的评分...\n",
      "预测出用户1对物品3556的评分：3.41537\n",
      "(1, 3556, 3.42)\n",
      "开始预测用户1对电影101864的评分...\n",
      "预测出用户1对物品101864的评分：3.55646\n",
      "(1, 101864, 3.56)\n",
      "开始预测用户1对电影3564的评分...\n",
      "预测出用户1对物品3564的评分：1.39989\n",
      "(1, 3564, 1.4)\n",
      "开始预测用户1对电影52722的评分...\n",
      "预测出用户1对物品52722的评分：3.08460\n",
      "(1, 52722, 3.08)\n",
      "开始预测用户1对电影69122的评分...\n",
      "预测出用户1对物品69122的评分：3.61595\n",
      "(1, 69122, 3.62)\n",
      "开始预测用户1对电影85510的评分...\n",
      "预测出用户1对物品85510的评分：3.09682\n",
      "(1, 85510, 3.1)\n",
      "开始预测用户1对电影3591的评分...\n",
      "预测出用户1对物品3591的评分：2.37746\n",
      "(1, 3591, 2.38)\n",
      "开始预测用户1对电影3593的评分...\n",
      "预测出用户1对物品3593的评分：1.59946\n",
      "(1, 3593, 1.6)\n",
      "开始预测用户1对电影44555的评分...\n",
      "预测出用户1对物品44555的评分：4.02379\n",
      "(1, 44555, 4.02)\n",
      "开始预测用户1对电影60950的评分...\n",
      "预测出用户1对物品60950的评分：3.47556\n",
      "(1, 60950, 3.48)\n",
      "开始预测用户1对电影110102的评分...\n",
      "预测出用户1对物品110102的评分：3.66596\n",
      "(1, 110102, 3.67)\n",
      "开始预测用户1对电影3608的评分...\n",
      "预测出用户1对物品3608的评分：3.05534\n",
      "(1, 3608, 3.06)\n",
      "开始预测用户1对电影3615的评分...\n",
      "预测出用户1对物品3615的评分：2.79635\n",
      "(1, 3615, 2.8)\n",
      "开始预测用户1对电影3618的评分...\n",
      "预测出用户1对物品3618的评分：3.48134\n",
      "(1, 3618, 3.48)\n",
      "开始预测用户1对电影3623的评分...\n",
      "预测出用户1对物品3623的评分：2.49876\n",
      "(1, 3623, 2.5)\n",
      "开始预测用户1对电影3624的评分...\n",
      "预测出用户1对物品3624的评分：3.28836\n",
      "(1, 3624, 3.29)\n",
      "开始预测用户1对电影3633的评分...\n",
      "预测出用户1对物品3633的评分：3.27110\n",
      "(1, 3633, 3.27)\n",
      "开始预测用户1对电影36401的评分...\n",
      "预测出用户1对物品36401的评分：2.51723\n",
      "(1, 36401, 2.52)\n",
      "开始预测用户1对电影3635的评分...\n",
      "预测出用户1对物品3635的评分：3.49705\n",
      "(1, 3635, 3.5)\n",
      "开始预测用户1对电影3638的评分...\n",
      "预测出用户1对物品3638的评分：2.99344\n",
      "(1, 3638, 2.99)\n",
      "开始预测用户1对电影3646的评分...\n",
      "预测出用户1对物品3646的评分：2.37937\n",
      "(1, 3646, 2.38)\n",
      "开始预测用户1对电影3654的评分...\n",
      "预测出用户1对物品3654的评分：3.60046\n",
      "(1, 3654, 3.6)\n",
      "开始预测用户1对电影3668的评分...\n",
      "预测出用户1对物品3668的评分：3.76063\n",
      "(1, 3668, 3.76)\n",
      "开始预测用户1对电影61024的评分...\n",
      "预测出用户1对物品61024的评分：3.89893\n",
      "(1, 61024, 3.9)\n",
      "开始预测用户1对电影3681的评分...\n",
      "预测出用户1对物品3681的评分：4.36519\n",
      "(1, 3681, 4.37)\n",
      "开始预测用户1对电影3683的评分...\n",
      "预测出用户1对物品3683的评分：3.99693\n",
      "(1, 3683, 4.0)\n",
      "开始预测用户1对电影3686的评分...\n",
      "预测出用户1对物品3686的评分：3.11433\n",
      "(1, 3686, 3.11)\n",
      "开始预测用户1对电影3688的评分...\n",
      "预测出用户1对物品3688的评分：2.48636\n",
      "(1, 3688, 2.49)\n",
      "开始预测用户1对电影3697的评分...\n",
      "预测出用户1对物品3697的评分：2.61349\n",
      "(1, 3697, 2.61)\n",
      "开始预测用户1对电影3698的评分...\n",
      "预测出用户1对物品3698的评分：3.01852\n",
      "(1, 3698, 3.02)\n",
      "开始预测用户1对电影3699的评分...\n",
      "预测出用户1对物品3699的评分：3.11481\n",
      "(1, 3699, 3.11)\n",
      "开始预测用户1对电影3701的评分...\n",
      "预测出用户1对物品3701的评分：2.91362\n",
      "(1, 3701, 2.91)\n",
      "开始预测用户1对电影3704的评分...\n",
      "预测出用户1对物品3704的评分：3.23174\n",
      "(1, 3704, 3.23)\n",
      "开始预测用户1对电影44665的评分...\n",
      "预测出用户1对物品44665的评分：3.80573\n",
      "(1, 44665, 3.81)\n",
      "开始预测用户1对电影3717的评分...\n",
      "预测出用户1对物品3717的评分：3.10070\n",
      "(1, 3717, 3.1)\n",
      "开始预测用户1对电影77455的评分...\n",
      "预测出用户1对物品77455的评分：4.19646\n",
      "(1, 77455, 4.2)\n",
      "开始预测用户1对电影93840的评分...\n",
      "预测出用户1对物品93840的评分：4.31652\n",
      "(1, 93840, 4.32)\n",
      "开始预测用户1对电影3730的评分...\n",
      "预测出用户1对物品3730的评分：4.31941\n",
      "(1, 3730, 4.32)\n",
      "开始预测用户1对电影3735的评分...\n",
      "预测出用户1对物品3735的评分：3.58690\n",
      "(1, 3735, 3.59)\n",
      "开始预测用户1对电影3741的评分...\n",
      "预测出用户1对物品3741的评分：4.04646\n",
      "(1, 3741, 4.05)\n",
      "开始预测用户1对电影3745的评分...\n",
      "预测出用户1对物品3745的评分：3.44878\n",
      "(1, 3745, 3.45)\n",
      "开始预测用户1对电影36517的评分...\n",
      "预测出用户1对物品36517的评分：3.55048\n",
      "(1, 36517, 3.55)\n",
      "开始预测用户1对电影3751的评分...\n",
      "预测出用户1对物品3751的评分：3.53071\n",
      "(1, 3751, 3.53)\n",
      "开始预测用户1对电影3752的评分...\n",
      "预测出用户1对物品3752的评分：3.01658\n",
      "(1, 3752, 3.02)\n",
      "开始预测用户1对电影3753的评分...\n",
      "预测出用户1对物品3753的评分：3.26673\n",
      "(1, 3753, 3.27)\n",
      "开始预测用户1对电影36519的评分...\n",
      "预测出用户1对物品36519的评分：3.18674\n",
      "(1, 36519, 3.19)\n",
      "开始预测用户1对电影3755的评分...\n",
      "预测出用户1对物品3755的评分：3.06975\n",
      "(1, 3755, 3.07)\n",
      "开始预测用户1对电影36529的评分...\n",
      "预测出用户1对物品36529的评分：3.59161\n",
      "(1, 36529, 3.59)\n",
      "开始预测用户1对电影3763的评分...\n",
      "预测出用户1对物品3763的评分：3.25348\n",
      "(1, 3763, 3.25)\n",
      "开始预测用户1对电影134853的评分...\n",
      "预测出用户1对物品134853的评分：4.04354\n",
      "(1, 134853, 4.04)\n",
      "开始预测用户1对电影3783的评分...\n",
      "预测出用户1对物品3783的评分：4.08359\n",
      "(1, 3783, 4.08)\n",
      "开始预测用户1对电影3784的评分...\n",
      "预测出用户1对物品3784的评分：2.17863\n",
      "(1, 3784, 2.18)\n",
      "开始预测用户1对电影3785的评分...\n",
      "预测出用户1对物品3785的评分：2.72737\n",
      "(1, 3785, 2.73)\n",
      "开始预测用户1对电影61132的评分...\n",
      "预测出用户1对物品61132的评分：3.35557\n",
      "(1, 61132, 3.36)\n",
      "开始预测用户1对电影3791的评分...\n",
      "预测出用户1对物品3791的评分：2.92401\n",
      "(1, 3791, 2.92)\n",
      "开始预测用户1对电影3798的评分...\n",
      "预测出用户1对物品3798的评分：3.29459\n",
      "(1, 3798, 3.29)\n",
      "开始预测用户1对电影44761的评分...\n",
      "预测出用户1对物品44761的评分：4.00270\n",
      "(1, 44761, 4.0)\n",
      "开始预测用户1对电影3812的评分...\n",
      "预测出用户1对物品3812的评分：3.31872\n",
      "(1, 3812, 3.32)\n",
      "开始预测用户1对电影102123的评分...\n",
      "预测出用户1对物品102123的评分：3.38478\n",
      "(1, 102123, 3.38)\n",
      "开始预测用户1对电影3821的评分...\n",
      "预测出用户1对物品3821的评分：2.22331\n",
      "(1, 3821, 2.22)\n",
      "开始预测用户1对电影52973的评分...\n",
      "预测出用户1对物品52973的评分：3.73481\n",
      "(1, 52973, 3.73)\n",
      "开始预测用户1对电影52975的评分...\n",
      "预测出用户1对物品52975的评分：3.29268\n",
      "(1, 52975, 3.29)\n",
      "开始预测用户1对电影3824的评分...\n",
      "预测出用户1对物品3824的评分：2.39956\n",
      "(1, 3824, 2.4)\n",
      "开始预测用户1对电影3825的评分...\n",
      "预测出用户1对物品3825的评分：2.42023\n",
      "(1, 3825, 2.42)\n",
      "开始预测用户1对电影3826的评分...\n",
      "预测出用户1对物品3826的评分：1.82422\n",
      "(1, 3826, 1.82)\n",
      "开始预测用户1对电影3827的评分...\n",
      "预测出用户1对物品3827的评分：2.98710\n",
      "(1, 3827, 2.99)\n",
      "开始预测用户1对电影102125的评分...\n",
      "预测出用户1对物品102125的评分：3.58392\n",
      "(1, 102125, 3.58)\n",
      "开始预测用户1对电影3831的评分...\n",
      "预测出用户1对物品3831的评分：3.86622\n",
      "(1, 3831, 3.87)\n",
      "开始预测用户1对电影77561的评分...\n",
      "预测出用户1对物品77561的评分：3.50296\n",
      "(1, 77561, 3.5)\n",
      "开始预测用户1对电影3836的评分...\n",
      "预测出用户1对物品3836的评分：4.22832\n",
      "(1, 3836, 4.23)\n",
      "开始预测用户1对电影53000的评分...\n",
      "预测出用户1对物品53000的评分：2.87177\n",
      "(1, 53000, 2.87)\n",
      "开始预测用户1对电影3852的评分...\n",
      "预测出用户1对物品3852的评分：3.55663\n",
      "(1, 3852, 3.56)\n",
      "开始预测用户1对电影3861的评分...\n",
      "预测出用户1对物品3861的评分：2.75669\n",
      "(1, 3861, 2.76)\n",
      "开始预测用户1对电影3863的评分...\n",
      "预测出用户1对物品3863的评分：2.96487\n",
      "(1, 3863, 2.96)\n",
      "开始预测用户1对电影3868的评分...\n",
      "预测出用户1对物品3868的评分：3.37306\n",
      "(1, 3868, 3.37)\n",
      "开始预测用户1对电影3869的评分...\n",
      "预测出用户1对物品3869的评分：3.37240\n",
      "(1, 3869, 3.37)\n",
      "开始预测用户1对电影69406的评分...\n",
      "预测出用户1对物品69406的评分：2.86292\n",
      "(1, 69406, 2.86)\n",
      "开始预测用户1对电影44840的评分...\n",
      "预测出用户1对物品44840的评分：2.81491\n",
      "(1, 44840, 2.81)\n",
      "开始预测用户1对电影3882的评分...\n",
      "预测出用户1对物品3882的评分：2.64726\n",
      "(1, 3882, 2.65)\n",
      "开始预测用户1对电影3893的评分...\n",
      "预测出用户1对物品3893的评分：3.27759\n",
      "(1, 3893, 3.28)\n",
      "开始预测用户1对电影61240的评分...\n",
      "预测出用户1对物品61240的评分：3.74603\n",
      "(1, 61240, 3.75)\n",
      "开始预测用户1对电影3897的评分...\n",
      "预测出用户1对物品3897的评分：3.81127\n",
      "(1, 3897, 3.81)\n",
      "开始预测用户1对电影122892的评分...\n",
      "预测出用户1对物品122892的评分：3.60292\n",
      "(1, 122892, 3.6)\n",
      "开始预测用户1对电影3910的评分...\n",
      "预测出用户1对物品3910的评分：4.01349\n",
      "(1, 3910, 4.01)\n",
      "开始预测用户1对电影3911的评分...\n",
      "预测出用户1对物品3911的评分：3.67027\n",
      "(1, 3911, 3.67)\n",
      "开始预测用户1对电影3916的评分...\n",
      "预测出用户1对物品3916的评分：3.50421\n",
      "(1, 3916, 3.5)\n",
      "开始预测用户1对电影3917的评分...\n",
      "预测出用户1对物品3917的评分：2.95404\n",
      "(1, 3917, 2.95)\n",
      "开始预测用户1对电影36708的评分...\n",
      "预测出用户1对物品36708的评分：3.72040\n",
      "(1, 36708, 3.72)\n",
      "开始预测用户1对电影122900的评分...\n",
      "预测出用户1对物品122900的评分：3.98248\n",
      "(1, 122900, 3.98)\n",
      "开始预测用户1对电影69481的评分...\n",
      "预测出用户1对物品69481的评分：3.86227\n",
      "(1, 69481, 3.86)\n",
      "开始预测用户1对电影3948的评分...\n",
      "预测出用户1对物品3948的评分：3.40195\n",
      "(1, 3948, 3.4)\n",
      "开始预测用户1对电影3949的评分...\n",
      "预测出用户1对物品3949的评分：3.93903\n",
      "(1, 3949, 3.94)\n",
      "开始预测用户1对电影3967的评分...\n",
      "预测出用户1对物品3967的评分：3.92201\n",
      "(1, 3967, 3.92)\n",
      "开始预测用户1对电影3968的评分...\n",
      "预测出用户1对物品3968的评分：3.06725\n",
      "(1, 3968, 3.07)\n",
      "开始预测用户1对电影3969的评分...\n",
      "预测出用户1对物品3969的评分：3.09758\n",
      "(1, 3969, 3.1)\n",
      "开始预测用户1对电影53121的评分...\n",
      "预测出用户1对物品53121的评分：2.37070\n",
      "(1, 53121, 2.37)\n",
      "开始预测用户1对电影3972的评分...\n",
      "预测出用户1对物品3972的评分：4.14482\n",
      "(1, 3972, 4.14)\n",
      "开始预测用户1对电影53125的评分...\n",
      "预测出用户1对物品53125的评分：3.43271\n",
      "(1, 53125, 3.43)\n",
      "开始预测用户1对电影3977的评分...\n",
      "预测出用户1对物品3977的评分：2.73755\n",
      "(1, 3977, 2.74)\n",
      "开始预测用户1对电影3978的评分...\n",
      "预测出用户1对物品3978的评分：2.89563\n",
      "(1, 3978, 2.9)\n",
      "开始预测用户1对电影3979的评分...\n",
      "预测出用户1对物品3979的评分：2.60660\n",
      "(1, 3979, 2.61)\n",
      "开始预测用户1对电影3980的评分...\n",
      "预测出用户1对物品3980的评分：3.09780\n",
      "(1, 3980, 3.1)\n",
      "开始预测用户1对电影3981的评分...\n",
      "预测出用户1对物品3981的评分：2.56013\n",
      "(1, 3981, 2.56)\n",
      "开始预测用户1对电影61323的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品61323的评分：3.54875\n",
      "(1, 61323, 3.55)\n",
      "开始预测用户1对电影3984的评分...\n",
      "预测出用户1对物品3984的评分：3.42962\n",
      "(1, 3984, 3.43)\n",
      "开始预测用户1对电影3986的评分...\n",
      "预测出用户1对物品3986的评分：2.64342\n",
      "(1, 3986, 2.64)\n",
      "开始预测用户1对电影3988的评分...\n",
      "预测出用户1对物品3988的评分：2.99226\n",
      "(1, 3988, 2.99)\n",
      "开始预测用户1对电影69526的评分...\n",
      "预测出用户1对物品69526的评分：2.10780\n",
      "(1, 69526, 2.11)\n",
      "开始预测用户1对电影3994的评分...\n",
      "预测出用户1对物品3994的评分：3.52110\n",
      "(1, 3994, 3.52)\n",
      "开始预测用户1对电影3996的评分...\n",
      "预测出用户1对物品3996的评分：3.91285\n",
      "(1, 3996, 3.91)\n",
      "开始预测用户1对电影3997的评分...\n",
      "预测出用户1对物品3997的评分：1.57223\n",
      "(1, 3997, 1.57)\n",
      "开始预测用户1对电影3998的评分...\n",
      "预测出用户1对物品3998的评分：2.78138\n",
      "(1, 3998, 2.78)\n",
      "开始预测用户1对电影3999的评分...\n",
      "预测出用户1对物品3999的评分：2.45545\n",
      "(1, 3999, 2.46)\n",
      "开始预测用户1对电影4002的评分...\n",
      "预测出用户1对物品4002的评分：3.99438\n",
      "(1, 4002, 3.99)\n",
      "开始预测用户1对电影4005的评分...\n",
      "预测出用户1对物品4005的评分：3.13743\n",
      "(1, 4005, 3.14)\n",
      "开始预测用户1对电影4007的评分...\n",
      "预测出用户1对物品4007的评分：3.59844\n",
      "(1, 4007, 3.6)\n",
      "开始预测用户1对电影4008的评分...\n",
      "预测出用户1对物品4008的评分：3.56468\n",
      "(1, 4008, 3.56)\n",
      "开始预测用户1对电影118696的评分...\n",
      "预测出用户1对物品118696的评分：4.08939\n",
      "(1, 118696, 4.09)\n",
      "开始预测用户1对电影4011的评分...\n",
      "预测出用户1对物品4011的评分：4.21384\n",
      "(1, 4011, 4.21)\n",
      "开始预测用户1对电影44972的评分...\n",
      "预测出用户1对物品44972的评分：2.33967\n",
      "(1, 44972, 2.34)\n",
      "开始预测用户1对电影4014的评分...\n",
      "预测出用户1对物品4014的评分：3.63714\n",
      "(1, 4014, 3.64)\n",
      "开始预测用户1对电影4015的评分...\n",
      "预测出用户1对物品4015的评分：2.62197\n",
      "(1, 4015, 2.62)\n",
      "开始预测用户1对电影4016的评分...\n",
      "预测出用户1对物品4016的评分：3.95713\n",
      "(1, 4016, 3.96)\n",
      "开始预测用户1对电影4017的评分...\n",
      "预测出用户1对物品4017的评分：3.57605\n",
      "(1, 4017, 3.58)\n",
      "开始预测用户1对电影4018的评分...\n",
      "预测出用户1对物品4018的评分：3.00600\n",
      "(1, 4018, 3.01)\n",
      "开始预测用户1对电影4019的评分...\n",
      "预测出用户1对物品4019的评分：3.61504\n",
      "(1, 4019, 3.62)\n",
      "开始预测用户1对电影4020的评分...\n",
      "预测出用户1对物品4020的评分：2.84063\n",
      "(1, 4020, 2.84)\n",
      "开始预测用户1对电影44974的评分...\n",
      "预测出用户1对物品44974的评分：3.07619\n",
      "(1, 44974, 3.08)\n",
      "开始预测用户1对电影4022的评分...\n",
      "预测出用户1对物品4022的评分：3.52198\n",
      "(1, 4022, 3.52)\n",
      "开始预测用户1对电影4023的评分...\n",
      "预测出用户1对物品4023的评分：3.18098\n",
      "(1, 4023, 3.18)\n",
      "开始预测用户1对电影4025的评分...\n",
      "预测出用户1对物品4025的评分：2.79819\n",
      "(1, 4025, 2.8)\n",
      "开始预测用户1对电影4027的评分...\n",
      "预测出用户1对物品4027的评分：3.85184\n",
      "(1, 4027, 3.85)\n",
      "开始预测用户1对电影4029的评分...\n",
      "预测出用户1对物品4029的评分：3.93948\n",
      "(1, 4029, 3.94)\n",
      "开始预测用户1对电影4033的评分...\n",
      "预测出用户1对物品4033的评分：3.98870\n",
      "(1, 4033, 3.99)\n",
      "开始预测用户1对电影4034的评分...\n",
      "预测出用户1对物品4034的评分：3.90279\n",
      "(1, 4034, 3.9)\n",
      "开始预测用户1对电影4036的评分...\n",
      "预测出用户1对物品4036的评分：2.68476\n",
      "(1, 4036, 2.68)\n",
      "开始预测用户1对电影4039的评分...\n",
      "预测出用户1对物品4039的评分：3.38269\n",
      "(1, 4039, 3.38)\n",
      "开始预测用户1对电影4040的评分...\n",
      "预测出用户1对物品4040的评分：2.35920\n",
      "(1, 4040, 2.36)\n",
      "开始预测用户1对电影4041的评分...\n",
      "预测出用户1对物品4041的评分：3.68938\n",
      "(1, 4041, 3.69)\n",
      "开始预测用户1对电影4054的评分...\n",
      "预测出用户1对物品4054的评分：2.98605\n",
      "(1, 4054, 2.99)\n",
      "开始预测用户1对电影110553的评分...\n",
      "预测出用户1对物品110553的评分：2.73533\n",
      "(1, 110553, 2.74)\n",
      "开始预测用户1对电影4069的评分...\n",
      "预测出用户1对物品4069的评分：2.91254\n",
      "(1, 4069, 2.91)\n",
      "开始预测用户1对电影135143的评分...\n",
      "预测出用户1对物品135143的评分：4.03736\n",
      "(1, 135143, 4.04)\n",
      "开始预测用户1对电影4084的评分...\n",
      "预测出用户1对物品4084的评分：2.80890\n",
      "(1, 4084, 2.81)\n",
      "开始预测用户1对电影4085的评分...\n",
      "预测出用户1对物品4085的评分：3.38231\n",
      "(1, 4085, 3.38)\n",
      "开始预测用户1对电影143355的评分...\n",
      "预测出用户1对物品143355的评分：3.90719\n",
      "(1, 143355, 3.91)\n",
      "开始预测用户1对电影102407的评分...\n",
      "预测出用户1对物品102407的评分：3.71104\n",
      "(1, 102407, 3.71)\n",
      "开始预测用户1对电影4105的评分...\n",
      "预测出用户1对物品4105的评分：3.70396\n",
      "(1, 4105, 3.7)\n",
      "开始预测用户1对电影69644的评分...\n",
      "预测出用户1对物品69644的评分：3.38844\n",
      "(1, 69644, 3.39)\n",
      "开始预测用户1对电影4121的评分...\n",
      "预测出用户1对物品4121的评分：3.23625\n",
      "(1, 4121, 3.24)\n",
      "开始预测用户1对电影45081的评分...\n",
      "预测出用户1对物品45081的评分：2.62915\n",
      "(1, 45081, 2.63)\n",
      "开始预测用户1对电影4128的评分...\n",
      "预测出用户1对物品4128的评分：3.68332\n",
      "(1, 4128, 3.68)\n",
      "开始预测用户1对电影102445的评分...\n",
      "预测出用户1对物品102445的评分：3.37773\n",
      "(1, 102445, 3.38)\n",
      "开始预测用户1对电影4144的评分...\n",
      "预测出用户1对物品4144的评分：4.30344\n",
      "(1, 4144, 4.3)\n",
      "开始预测用户1对电影4148的评分...\n",
      "预测出用户1对物品4148的评分：2.99066\n",
      "(1, 4148, 2.99)\n",
      "开始预测用户1对电影4149的评分...\n",
      "预测出用户1对物品4149的评分：2.72670\n",
      "(1, 4149, 2.73)\n",
      "开始预测用户1对电影4153的评分...\n",
      "预测出用户1对物品4153的评分：2.20552\n",
      "(1, 4153, 2.21)\n",
      "开始预测用户1对电影4161的评分...\n",
      "预测出用户1对物品4161的评分：3.09780\n",
      "(1, 4161, 3.1)\n",
      "开始预测用户1对电影53322的评分...\n",
      "预测出用户1对物品53322的评分：3.62394\n",
      "(1, 53322, 3.62)\n",
      "开始预测用户1对电影4214的评分...\n",
      "预测出用户1对物品4214的评分：3.00116\n",
      "(1, 4214, 3.0)\n",
      "开始预测用户1对电影69757的评分...\n",
      "预测出用户1对物品69757的评分：3.82946\n",
      "(1, 69757, 3.83)\n",
      "开始预测用户1对电影4223的评分...\n",
      "预测出用户1对物品4223的评分：3.68324\n",
      "(1, 4223, 3.68)\n",
      "开始预测用户1对电影4226的评分...\n",
      "预测出用户1对物品4226的评分：4.10478\n",
      "(1, 4226, 4.1)\n",
      "开始预测用户1对电影45186的评分...\n",
      "预测出用户1对物品45186的评分：3.45456\n",
      "(1, 45186, 3.45)\n",
      "开始预测用户1对电影4232的评分...\n",
      "预测出用户1对物品4232的评分：2.65192\n",
      "(1, 4232, 2.65)\n",
      "开始预测用户1对电影4235的评分...\n",
      "预测出用户1对物品4235的评分：3.95999\n",
      "(1, 4235, 3.96)\n",
      "开始预测用户1对电影4238的评分...\n",
      "预测出用户1对物品4238的评分：2.86646\n",
      "(1, 4238, 2.87)\n",
      "开始预测用户1对电影4239的评分...\n",
      "预测出用户1对物品4239的评分：3.82783\n",
      "(1, 4239, 3.83)\n",
      "开始预测用户1对电影4246的评分...\n",
      "预测出用户1对物品4246的评分：3.50353\n",
      "(1, 4246, 3.5)\n",
      "开始预测用户1对电影4247的评分...\n",
      "预测出用户1对物品4247的评分：2.20234\n",
      "(1, 4247, 2.2)\n",
      "开始预测用户1对电影4254的评分...\n",
      "预测出用户1对物品4254的评分：1.73146\n",
      "(1, 4254, 1.73)\n",
      "开始预测用户1对电影4262的评分...\n",
      "预测出用户1对物品4262的评分：3.96131\n",
      "(1, 4262, 3.96)\n",
      "开始预测用户1对电影4270的评分...\n",
      "预测出用户1对物品4270的评分：2.76022\n",
      "(1, 4270, 2.76)\n",
      "开始预测用户1对电影86190的评分...\n",
      "预测出用户1对物品86190的评分：3.64092\n",
      "(1, 86190, 3.64)\n",
      "开始预测用户1对电影4291的评分...\n",
      "预测出用户1对物品4291的评分：2.66405\n",
      "(1, 4291, 2.66)\n",
      "开始预测用户1对电影4299的评分...\n",
      "预测出用户1对物品4299的评分：3.43983\n",
      "(1, 4299, 3.44)\n",
      "开始预测用户1对电影4306的评分...\n",
      "预测出用户1对物品4306的评分：3.72415\n",
      "(1, 4306, 3.72)\n",
      "开始预测用户1对电影4308的评分...\n",
      "预测出用户1对物品4308的评分：3.79334\n",
      "(1, 4308, 3.79)\n",
      "开始预测用户1对电影69844的评分...\n",
      "预测出用户1对物品69844的评分：3.88377\n",
      "(1, 69844, 3.88)\n",
      "开始预测用户1对电影4310的评分...\n",
      "预测出用户1对物品4310的评分：2.78763\n",
      "(1, 4310, 2.79)\n",
      "开始预测用户1对电影53464的评分...\n",
      "预测出用户1对物品53464的评分：2.42986\n",
      "(1, 53464, 2.43)\n",
      "开始预测用户1对电影4321的评分...\n",
      "预测出用户1对物品4321的评分：3.38840\n",
      "(1, 4321, 3.39)\n",
      "开始预测用户1对电影4326的评分...\n",
      "预测出用户1对物品4326的评分：3.52653\n",
      "(1, 4326, 3.53)\n",
      "开始预测用户1对电影4327的评分...\n",
      "预测出用户1对物品4327的评分：3.80550\n",
      "(1, 4327, 3.81)\n",
      "开始预测用户1对电影176371的评分...\n",
      "预测出用户1对物品176371的评分：3.40248\n",
      "(1, 176371, 3.4)\n",
      "开始预测用户1对电影4340的评分...\n",
      "预测出用户1对物品4340的评分：2.18604\n",
      "(1, 4340, 2.19)\n",
      "开始预测用户1对电影4343的评分...\n",
      "预测出用户1对物品4343的评分：2.89330\n",
      "(1, 4343, 2.89)\n",
      "开始预测用户1对电影4344的评分...\n",
      "预测出用户1对物品4344的评分：3.29583\n",
      "(1, 4344, 3.3)\n",
      "开始预测用户1对电影4351的评分...\n",
      "预测出用户1对物品4351的评分：3.19297\n",
      "(1, 4351, 3.19)\n",
      "开始预测用户1对电影4361的评分...\n",
      "预测出用户1对物品4361的评分：3.43196\n",
      "(1, 4361, 3.43)\n",
      "开始预测用户1对电影4366的评分...\n",
      "预测出用户1对物品4366的评分：3.41521\n",
      "(1, 4366, 3.42)\n",
      "开始预测用户1对电影4367的评分...\n",
      "预测出用户1对物品4367的评分：2.35073\n",
      "(1, 4367, 2.35)\n",
      "开始预测用户1对电影4368的评分...\n",
      "预测出用户1对物品4368的评分：2.65792\n",
      "(1, 4368, 2.66)\n",
      "开始预测用户1对电影4369的评分...\n",
      "预测出用户1对物品4369的评分：2.80270\n",
      "(1, 4369, 2.8)\n",
      "开始预测用户1对电影4370的评分...\n",
      "预测出用户1对物品4370的评分：3.32476\n",
      "(1, 4370, 3.32)\n",
      "开始预测用户1对电影53519的评分...\n",
      "预测出用户1对物品53519的评分：3.04519\n",
      "(1, 53519, 3.05)\n",
      "开始预测用户1对电影78105的评分...\n",
      "预测出用户1对物品78105的评分：2.53786\n",
      "(1, 78105, 2.54)\n",
      "开始预测用户1对电影4378的评分...\n",
      "预测出用户1对物品4378的评分：3.73989\n",
      "(1, 4378, 3.74)\n",
      "开始预测用户1对电影4386的评分...\n",
      "预测出用户1对物品4386的评分：2.39853\n",
      "(1, 4386, 2.4)\n",
      "开始预测用户1对电影4388的评分...\n",
      "预测出用户1对物品4388的评分：2.61966\n",
      "(1, 4388, 2.62)\n",
      "开始预测用户1对电影168250的评分...\n",
      "预测出用户1对物品168250的评分：3.39909\n",
      "(1, 168250, 3.4)\n",
      "开始预测用户1对电影86332的评分...\n",
      "预测出用户1对物品86332的评分：3.48778\n",
      "(1, 86332, 3.49)\n",
      "开始预测用户1对电影168252的评分...\n",
      "预测出用户1对物品168252的评分：4.51528\n",
      "(1, 168252, 4.52)\n",
      "开始预测用户1对电影69951的评分...\n",
      "预测出用户1对物品69951的评分：4.05412\n",
      "(1, 69951, 4.05)\n",
      "开始预测用户1对电影4446的评分...\n",
      "预测出用户1对物品4446的评分：3.25640\n",
      "(1, 4446, 3.26)\n",
      "开始预测用户1对电影4447的评分...\n",
      "预测出用户1对物品4447的评分：2.90532\n",
      "(1, 4447, 2.91)\n",
      "开始预测用户1对电影4448的评分...\n",
      "预测出用户1对物品4448的评分：3.59803\n",
      "(1, 4448, 3.6)\n",
      "开始预测用户1对电影119141的评分...\n",
      "预测出用户1对物品119141的评分：3.45994\n",
      "(1, 119141, 3.46)\n",
      "开始预测用户1对电影119145的评分...\n",
      "预测出用户1对物品119145的评分：4.06295\n",
      "(1, 119145, 4.06)\n",
      "开始预测用户1对电影135536的评分...\n",
      "预测出用户1对物品135536的评分：3.16302\n",
      "(1, 135536, 3.16)\n",
      "开始预测用户1对电影4467的评分...\n",
      "预测出用户1对物品4467的评分：3.84553\n",
      "(1, 4467, 3.85)\n",
      "开始预测用户1对电影45431的评分...\n",
      "预测出用户1对物品45431的评分：3.36798\n",
      "(1, 45431, 3.37)\n",
      "开始预测用户1对电影4487的评分...\n",
      "预测出用户1对物品4487的评分：2.63943\n",
      "(1, 4487, 2.64)\n",
      "开始预测用户1对电影45447的评分...\n",
      "预测出用户1对物品45447的评分：3.18435\n",
      "(1, 45447, 3.18)\n",
      "开始预测用户1对电影4489的评分...\n",
      "预测出用户1对物品4489的评分：3.39533\n",
      "(1, 4489, 3.4)\n",
      "开始预测用户1对电影135569的评分...\n",
      "预测出用户1对物品135569的评分：3.44969\n",
      "(1, 135569, 3.45)\n",
      "开始预测用户1对电影4499的评分...\n",
      "预测出用户1对物品4499的评分：4.28897\n",
      "(1, 4499, 4.29)\n",
      "开始预测用户1对电影45499的评分...\n",
      "预测出用户1对物品45499的评分：3.10397\n",
      "(1, 45499, 3.1)\n",
      "开始预测用户1对电影45501的评分...\n",
      "预测出用户1对物品45501的评分：2.59526\n",
      "(1, 45501, 2.6)\n",
      "开始预测用户1对电影4545的评分...\n",
      "预测出用户1对物品4545的评分：3.17788\n",
      "(1, 4545, 3.18)\n",
      "开始预测用户1对电影45517的评分...\n",
      "预测出用户1对物品45517的评分：3.32538\n",
      "(1, 45517, 3.33)\n",
      "开始预测用户1对电影4558的评分...\n",
      "预测出用户1对物品4558的评分：2.20643\n",
      "(1, 4558, 2.21)\n",
      "开始预测用户1对电影94677的评分...\n",
      "预测出用户1对物品94677的评分：3.99103\n",
      "(1, 94677, 3.99)\n",
      "开始预测用户1对电影4571的评分...\n",
      "预测出用户1对物品4571的评分：3.65699\n",
      "(1, 4571, 3.66)\n",
      "开始预测用户1对电影102903的评分...\n",
      "预测出用户1对物品102903的评分：3.98152\n",
      "(1, 102903, 3.98)\n",
      "开始预测用户1对电影37384的评分...\n",
      "预测出用户1对物品37384的评分：3.00076\n",
      "(1, 37384, 3.0)\n",
      "开始预测用户1对电影111113的评分...\n",
      "预测出用户1对物品111113的评分：3.73420\n",
      "(1, 111113, 3.73)\n",
      "开始预测用户1对电影37386的评分...\n",
      "预测出用户1对物品37386的评分：2.32070\n",
      "(1, 37386, 2.32)\n",
      "开始预测用户1对电影4621的评分...\n",
      "预测出用户1对物品4621的评分：2.12835\n",
      "(1, 4621, 2.13)\n",
      "开始预测用户1对电影152077的评分...\n",
      "预测出用户1对物品152077的评分：3.71843\n",
      "(1, 152077, 3.72)\n",
      "开始预测用户1对电影4623的评分...\n",
      "预测出用户1对物品4623的评分：3.59836\n",
      "(1, 4623, 3.6)\n",
      "开始预测用户1对电影152081的评分...\n",
      "预测出用户1对物品152081的评分：3.97831\n",
      "(1, 152081, 3.98)\n",
      "开始预测用户1对电影4638的评分...\n",
      "预测出用户1对物品4638的评分：2.54196\n",
      "(1, 4638, 2.54)\n",
      "开始预测用户1对电影4639的评分...\n",
      "预测出用户1对物品4639的评分：2.52049\n",
      "(1, 4639, 2.52)\n",
      "开始预测用户1对电影4641的评分...\n",
      "预测出用户1对物品4641的评分：3.60518\n",
      "(1, 4641, 3.61)\n",
      "开始预测用户1对电影4642的评分...\n",
      "预测出用户1对物品4642的评分：4.16018\n",
      "(1, 4642, 4.16)\n",
      "开始预测用户1对电影4643的评分...\n",
      "预测出用户1对物品4643的评分：2.79306\n",
      "(1, 4643, 2.79)\n",
      "开始预测用户1对电影70183的评分...\n",
      "预测出用户1对物品70183的评分：3.68374\n",
      "(1, 70183, 3.68)\n",
      "开始预测用户1对电影94777的评分...\n",
      "预测出用户1对物品94777的评分：3.32046\n",
      "(1, 94777, 3.32)\n",
      "开始预测用户1对电影4677的评分...\n",
      "预测出用户1对物品4677的评分：2.91767\n",
      "(1, 4677, 2.92)\n",
      "开始预测用户1对电影4679的评分...\n",
      "预测出用户1对物品4679的评分：2.86634\n",
      "(1, 4679, 2.87)\n",
      "开始预测用户1对电影4700的评分...\n",
      "预测出用户1对物品4700的评分：3.26557\n",
      "(1, 4700, 3.27)\n",
      "开始预测用户1对电影4701的评分...\n",
      "预测出用户1对物品4701的评分：3.18663\n",
      "(1, 4701, 3.19)\n",
      "开始预测用户1对电影45666的评分...\n",
      "预测出用户1对物品45666的评分：2.33371\n",
      "(1, 45666, 2.33)\n",
      "开始预测用户1对电影45672的评分...\n",
      "预测出用户1对物品45672的评分：3.03904\n",
      "(1, 45672, 3.04)\n",
      "开始预测用户1对电影4718的评分...\n",
      "预测出用户1对物品4718的评分：2.96537\n",
      "(1, 4718, 2.97)\n",
      "开始预测用户1对电影4720的评分...\n",
      "预测出用户1对物品4720的评分：3.37114\n",
      "(1, 4720, 3.37)\n",
      "开始预测用户1对电影4728的评分...\n",
      "预测出用户1对物品4728的评分：2.92746\n",
      "(1, 4728, 2.93)\n",
      "开始预测用户1对电影4734的评分...\n",
      "预测出用户1对物品4734的评分：2.95178\n",
      "(1, 4734, 2.95)\n",
      "开始预测用户1对电影103042的评分...\n",
      "预测出用户1对物品103042的评分：3.24876\n",
      "(1, 103042, 3.25)\n",
      "开始预测用户1对电影78469的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品78469的评分：3.00954\n",
      "(1, 78469, 3.01)\n",
      "开始预测用户1对电影53894的评分...\n",
      "预测出用户1对物品53894的评分：3.67725\n",
      "(1, 53894, 3.68)\n",
      "开始预测用户1对电影70286的评分...\n",
      "预测出用户1对物品70286的评分：3.65852\n",
      "(1, 70286, 3.66)\n",
      "开始预测用户1对电影94864的评分...\n",
      "预测出用户1对物品94864的评分：3.03651\n",
      "(1, 94864, 3.04)\n",
      "开始预测用户1对电影70293的评分...\n",
      "预测出用户1对物品70293的评分：2.60700\n",
      "(1, 70293, 2.61)\n",
      "开始预测用户1对电影45720的评分...\n",
      "预测出用户1对物品45720的评分：3.72554\n",
      "(1, 45720, 3.73)\n",
      "开始预测用户1对电影45722的评分...\n",
      "预测出用户1对物品45722的评分：3.40243\n",
      "(1, 45722, 3.4)\n",
      "开始预测用户1对电影45728的评分...\n",
      "预测出用户1对物品45728的评分：3.95508\n",
      "(1, 45728, 3.96)\n",
      "开始预测用户1对电影78499的评分...\n",
      "预测出用户1对物品78499的评分：3.90893\n",
      "(1, 78499, 3.91)\n",
      "开始预测用户1对电影4776的评分...\n",
      "预测出用户1对物品4776的评分：3.70286\n",
      "(1, 4776, 3.7)\n",
      "开始预测用户1对电影53953的评分...\n",
      "预测出用户1对物品53953的评分：2.92764\n",
      "(1, 53953, 2.93)\n",
      "开始预测用户1对电影135887的评分...\n",
      "预测出用户1对物品135887的评分：3.53095\n",
      "(1, 135887, 3.53)\n",
      "开始预测用户1对电影4816的评分...\n",
      "预测出用户1对物品4816的评分：3.58811\n",
      "(1, 4816, 3.59)\n",
      "开始预测用户1对电影53972的评分...\n",
      "预测出用户1对物品53972的评分：3.43041\n",
      "(1, 53972, 3.43)\n",
      "开始预测用户1对电影4823的评分...\n",
      "预测出用户1对物品4823的评分：3.18712\n",
      "(1, 4823, 3.19)\n",
      "开始预测用户1对电影103141的评分...\n",
      "预测出用户1对物品103141的评分：4.08750\n",
      "(1, 103141, 4.09)\n",
      "开始预测用户1对电影53993的评分...\n",
      "预测出用户1对物品53993的评分：2.91075\n",
      "(1, 53993, 2.91)\n",
      "开始预测用户1对电影53996的评分...\n",
      "预测出用户1对物品53996的评分：3.57827\n",
      "(1, 53996, 3.58)\n",
      "开始预测用户1对电影94959的评分...\n",
      "预测出用户1对物品94959的评分：3.79991\n",
      "(1, 94959, 3.8)\n",
      "开始预测用户1对电影4848的评分...\n",
      "预测出用户1对物品4848的评分：3.63635\n",
      "(1, 4848, 3.64)\n",
      "开始预测用户1对电影54001的评分...\n",
      "预测出用户1对物品54001的评分：3.92834\n",
      "(1, 54001, 3.93)\n",
      "开始预测用户1对电影54004的评分...\n",
      "预测出用户1对物品54004的评分：3.66518\n",
      "(1, 54004, 3.67)\n",
      "开始预测用户1对电影4855的评分...\n",
      "预测出用户1对物品4855的评分：3.77218\n",
      "(1, 4855, 3.77)\n",
      "开始预测用户1对电影111360的评分...\n",
      "预测出用户1对物品111360的评分：2.98305\n",
      "(1, 111360, 2.98)\n",
      "开始预测用户1对电影4865的评分...\n",
      "预测出用户1对物品4865的评分：3.48412\n",
      "(1, 4865, 3.48)\n",
      "开始预测用户1对电影111362的评分...\n",
      "预测出用户1对物品111362的评分：4.00169\n",
      "(1, 111362, 4.0)\n",
      "开始预测用户1对电影111364的评分...\n",
      "预测出用户1对物品111364的评分：2.86637\n",
      "(1, 111364, 2.87)\n",
      "开始预测用户1对电影4873的评分...\n",
      "预测出用户1对物品4873的评分：3.98821\n",
      "(1, 4873, 3.99)\n",
      "开始预测用户1对电影4874的评分...\n",
      "预测出用户1对物品4874的评分：3.42615\n",
      "(1, 4874, 3.43)\n",
      "开始预测用户1对电影4876的评分...\n",
      "预测出用户1对物品4876的评分：2.47508\n",
      "(1, 4876, 2.48)\n",
      "开始预测用户1对电影4878的评分...\n",
      "预测出用户1对物品4878的评分：3.96270\n",
      "(1, 4878, 3.96)\n",
      "开始预测用户1对电影4881的评分...\n",
      "预测出用户1对物品4881的评分：3.75398\n",
      "(1, 4881, 3.75)\n",
      "开始预测用户1对电影4886的评分...\n",
      "预测出用户1对物品4886的评分：3.90056\n",
      "(1, 4886, 3.9)\n",
      "开始预测用户1对电影4887的评分...\n",
      "预测出用户1对物品4887的评分：2.29970\n",
      "(1, 4887, 2.3)\n",
      "开始预测用户1对电影4890的评分...\n",
      "预测出用户1对物品4890的评分：2.93452\n",
      "(1, 4890, 2.93)\n",
      "开始预测用户1对电影4896的评分...\n",
      "预测出用户1对物品4896的评分：3.74943\n",
      "(1, 4896, 3.75)\n",
      "开始预测用户1对电影4901的评分...\n",
      "预测出用户1对物品4901的评分：3.49793\n",
      "(1, 4901, 3.5)\n",
      "开始预测用户1对电影86833的评分...\n",
      "预测出用户1对物品86833的评分：4.04410\n",
      "(1, 86833, 4.04)\n",
      "开始预测用户1对电影45880的评分...\n",
      "预测出用户1对物品45880的评分：2.90168\n",
      "(1, 45880, 2.9)\n",
      "开始预测用户1对电影103228的评分...\n",
      "预测出用户1对物品103228的评分：3.42930\n",
      "(1, 103228, 3.43)\n",
      "开始预测用户1对电影103249的评分...\n",
      "预测出用户1对物品103249的评分：2.99123\n",
      "(1, 103249, 2.99)\n",
      "开始预测用户1对电影136020的评分...\n",
      "预测出用户1对物品136020的评分：3.07302\n",
      "(1, 136020, 3.07)\n",
      "开始预测用户1对电影103253的评分...\n",
      "预测出用户1对物品103253的评分：3.33008\n",
      "(1, 103253, 3.33)\n",
      "开始预测用户1对电影4954的评分...\n",
      "预测出用户1对物品4954的评分：3.63613\n",
      "(1, 4954, 3.64)\n",
      "开始预测用户1对电影4958的评分...\n",
      "预测出用户1对物品4958的评分：3.40495\n",
      "(1, 4958, 3.4)\n",
      "开始预测用户1对电影37727的评分...\n",
      "预测出用户1对物品37727的评分：2.71406\n",
      "(1, 37727, 2.71)\n",
      "开始预测用户1对电影86880的评分...\n",
      "预测出用户1对物品86880的评分：3.37965\n",
      "(1, 86880, 3.38)\n",
      "开始预测用户1对电影37729的评分...\n",
      "预测出用户1对物品37729的评分：3.64817\n",
      "(1, 37729, 3.65)\n",
      "开始预测用户1对电影86882的评分...\n",
      "预测出用户1对物品86882的评分：3.80076\n",
      "(1, 86882, 3.8)\n",
      "开始预测用户1对电影4963的评分...\n",
      "预测出用户1对物品4963的评分：3.80787\n",
      "(1, 4963, 3.81)\n",
      "开始预测用户1对电影37733的评分...\n",
      "预测出用户1对物品37733的评分：3.45489\n",
      "(1, 37733, 3.45)\n",
      "开始预测用户1对电影4967的评分...\n",
      "预测出用户1对物品4967的评分：4.31707\n",
      "(1, 4967, 4.32)\n",
      "开始预测用户1对电影4973的评分...\n",
      "预测出用户1对物品4973的评分：4.22948\n",
      "(1, 4973, 4.23)\n",
      "开始预测用户1对电影4974的评分...\n",
      "预测出用户1对物品4974的评分：2.39854\n",
      "(1, 4974, 2.4)\n",
      "开始预测用户1对电影4975的评分...\n",
      "预测出用户1对物品4975的评分：3.41415\n",
      "(1, 4975, 3.41)\n",
      "开始预测用户1对电影37741的评分...\n",
      "预测出用户1对物品37741的评分：3.90017\n",
      "(1, 37741, 3.9)\n",
      "开始预测用户1对电影4979的评分...\n",
      "预测出用户1对物品4979的评分：3.82452\n",
      "(1, 4979, 3.82)\n",
      "开始预测用户1对电影4980的评分...\n",
      "预测出用户1对物品4980的评分：2.92925\n",
      "(1, 4980, 2.93)\n",
      "开始预测用户1对电影45950的评分...\n",
      "预测出用户1对物品45950的评分：3.57881\n",
      "(1, 45950, 3.58)\n",
      "开始预测用户1对电影86911的评分...\n",
      "预测出用户1对物品86911的评分：3.09538\n",
      "(1, 86911, 3.1)\n",
      "开始预测用户1对电影4992的评分...\n",
      "预测出用户1对物品4992的评分：3.30689\n",
      "(1, 4992, 3.31)\n",
      "开始预测用户1对电影4993的评分...\n",
      "预测出用户1对物品4993的评分：4.19182\n",
      "(1, 4993, 4.19)\n",
      "开始预测用户1对电影4995的评分...\n",
      "预测出用户1对物品4995的评分：4.02851\n",
      "(1, 4995, 4.03)\n",
      "开始预测用户1对电影5010的评分...\n",
      "预测出用户1对物品5010的评分：3.56667\n",
      "(1, 5010, 3.57)\n",
      "开始预测用户1对电影5013的评分...\n",
      "预测出用户1对物品5013的评分：3.82490\n",
      "(1, 5013, 3.82)\n",
      "开始预测用户1对电影5014的评分...\n",
      "预测出用户1对物品5014的评分：4.06036\n",
      "(1, 5014, 4.06)\n",
      "开始预测用户1对电影5015的评分...\n",
      "预测出用户1对物品5015的评分：3.49168\n",
      "(1, 5015, 3.49)\n",
      "开始预测用户1对电影5025的评分...\n",
      "预测出用户1对物品5025的评分：2.52316\n",
      "(1, 5025, 2.52)\n",
      "开始预测用户1对电影5026的评分...\n",
      "预测出用户1对物品5026的评分：3.60283\n",
      "(1, 5026, 3.6)\n",
      "开始预测用户1对电影62374的评分...\n",
      "预测出用户1对物品62374的评分：4.13279\n",
      "(1, 62374, 4.13)\n",
      "开始预测用户1对电影103335的评分...\n",
      "预测出用户1对物品103335的评分：3.95848\n",
      "(1, 103335, 3.96)\n",
      "开始预测用户1对电影103341的评分...\n",
      "预测出用户1对物品103341的评分：3.81589\n",
      "(1, 103341, 3.82)\n",
      "开始预测用户1对电影54190的评分...\n",
      "预测出用户1对物品54190的评分：4.04063\n",
      "(1, 54190, 4.04)\n",
      "开始预测用户1对电影5049的评分...\n",
      "预测出用户1对物品5049的评分：3.40386\n",
      "(1, 5049, 3.4)\n",
      "开始预测用户1对电影95167的评分...\n",
      "预测出用户1对物品95167的评分：3.59123\n",
      "(1, 95167, 3.59)\n",
      "开始预测用户1对电影5064的评分...\n",
      "预测出用户1对物品5064的评分：3.84435\n",
      "(1, 5064, 3.84)\n",
      "开始预测用户1对电影5065的评分...\n",
      "预测出用户1对物品5065的评分：2.99728\n",
      "(1, 5065, 3.0)\n",
      "开始预测用户1对电影5066的评分...\n",
      "预测出用户1对物品5066的评分：3.11333\n",
      "(1, 5066, 3.11)\n",
      "开始预测用户1对电影5072的评分...\n",
      "预测出用户1对物品5072的评分：3.90452\n",
      "(1, 5072, 3.9)\n",
      "开始预测用户1对电影62434的评分...\n",
      "预测出用户1对物品62434的评分：3.80159\n",
      "(1, 62434, 3.8)\n",
      "开始预测用户1对电影5103的评分...\n",
      "预测出用户1对物品5103的评分：3.26684\n",
      "(1, 5103, 3.27)\n",
      "开始预测用户1对电影54259的评分...\n",
      "预测出用户1对物品54259的评分：3.53249\n",
      "(1, 54259, 3.53)\n",
      "开始预测用户1对电影5108的评分...\n",
      "预测出用户1对物品5108的评分：3.10886\n",
      "(1, 5108, 3.11)\n",
      "开始预测用户1对电影5110的评分...\n",
      "预测出用户1对物品5110的评分：3.58744\n",
      "(1, 5110, 3.59)\n",
      "开始预测用户1对电影54272的评分...\n",
      "预测出用户1对物品54272的评分：3.82958\n",
      "(1, 54272, 3.83)\n",
      "开始预测用户1对电影5128的评分...\n",
      "预测出用户1对物品5128的评分：2.43334\n",
      "(1, 5128, 2.43)\n",
      "开始预测用户1对电影54286的评分...\n",
      "预测出用户1对物品54286的评分：3.50230\n",
      "(1, 54286, 3.5)\n",
      "开始预测用户1对电影5135的评分...\n",
      "预测出用户1对物品5135的评分：3.64477\n",
      "(1, 5135, 3.64)\n",
      "开始预测用户1对电影5151的评分...\n",
      "预测出用户1对物品5151的评分：3.07844\n",
      "(1, 5151, 3.08)\n",
      "开始预测用户1对电影5152的评分...\n",
      "预测出用户1对物品5152的评分：3.13780\n",
      "(1, 5152, 3.14)\n",
      "开始预测用户1对电影111659的评分...\n",
      "预测出用户1对物品111659的评分：3.13183\n",
      "(1, 111659, 3.13)\n",
      "开始预测用户1对电影5171的评分...\n",
      "预测出用户1对物品5171的评分：2.81700\n",
      "(1, 5171, 2.82)\n",
      "开始预测用户1对电影5218的评分...\n",
      "预测出用户1对物品5218的评分：3.73442\n",
      "(1, 5218, 3.73)\n",
      "开始预测用户1对电影5219的评分...\n",
      "预测出用户1对物品5219的评分：3.00570\n",
      "(1, 5219, 3.01)\n",
      "开始预测用户1对电影5225的评分...\n",
      "预测出用户1对物品5225的评分：4.06752\n",
      "(1, 5225, 4.07)\n",
      "开始预测用户1对电影111743的评分...\n",
      "预测出用户1对物品111743的评分：3.24703\n",
      "(1, 111743, 3.25)\n",
      "开始预测用户1对电影5254的评分...\n",
      "预测出用户1对物品5254的评分：2.94634\n",
      "(1, 5254, 2.95)\n",
      "开始预测用户1对电影111759的评分...\n",
      "预测出用户1对物品111759的评分：3.97756\n",
      "(1, 111759, 3.98)\n",
      "开始预测用户1对电影5265的评分...\n",
      "预测出用户1对物品5265的评分：3.02756\n",
      "(1, 5265, 3.03)\n",
      "开始预测用户1对电影5266的评分...\n",
      "预测出用户1对物品5266的评分：3.14822\n",
      "(1, 5266, 3.15)\n",
      "开始预测用户1对电影5267的评分...\n",
      "预测出用户1对物品5267的评分：3.42206\n",
      "(1, 5267, 3.42)\n",
      "开始预测用户1对电影38038的评分...\n",
      "预测出用户1对物品38038的评分：3.73674\n",
      "(1, 38038, 3.74)\n",
      "开始预测用户1对电影5283的评分...\n",
      "预测出用户1对物品5283的评分：2.87177\n",
      "(1, 5283, 2.87)\n",
      "开始预测用户1对电影111781的评分...\n",
      "预测出用户1对物品111781的评分：3.35496\n",
      "(1, 111781, 3.35)\n",
      "开始预测用户1对电影5291的评分...\n",
      "预测出用户1对物品5291的评分：4.05045\n",
      "(1, 5291, 4.05)\n",
      "开始预测用户1对电影38061的评分...\n",
      "预测出用户1对物品38061的评分：4.17349\n",
      "(1, 38061, 4.17)\n",
      "开始预测用户1对电影5294的评分...\n",
      "预测出用户1对物品5294的评分：3.60923\n",
      "(1, 5294, 3.61)\n",
      "开始预测用户1对电影5299的评分...\n",
      "预测出用户1对物品5299的评分：3.12355\n",
      "(1, 5299, 3.12)\n",
      "开始预测用户1对电影87222的评分...\n",
      "预测出用户1对物品87222的评分：3.55552\n",
      "(1, 87222, 3.56)\n",
      "开始预测用户1对电影5308的评分...\n",
      "预测出用户1对物品5308的评分：2.98512\n",
      "(1, 5308, 2.99)\n",
      "开始预测用户1对电影87232的评分...\n",
      "预测出用户1对物品87232的评分：3.93125\n",
      "(1, 87232, 3.93)\n",
      "开始预测用户1对电影5313的评分...\n",
      "预测出用户1对物品5313的评分：1.72830\n",
      "(1, 5313, 1.73)\n",
      "开始预测用户1对电影95441的评分...\n",
      "预测出用户1对物品95441的评分：3.27487\n",
      "(1, 95441, 3.27)\n",
      "开始预测用户1对电影5349的评分...\n",
      "预测出用户1对物品5349的评分：3.58489\n",
      "(1, 5349, 3.58)\n",
      "开始预测用户1对电影54503的评分...\n",
      "预测出用户1对物品54503的评分：4.12585\n",
      "(1, 54503, 4.13)\n",
      "开始预测用户1对电影79091的评分...\n",
      "预测出用户1对物品79091的评分：3.66613\n",
      "(1, 79091, 3.67)\n",
      "开始预测用户1对电影46335的评分...\n",
      "预测出用户1对物品46335的评分：2.05727\n",
      "(1, 46335, 2.06)\n",
      "开始预测用户1对电影5377的评分...\n",
      "预测出用户1对物品5377的评分：3.73072\n",
      "(1, 5377, 3.73)\n",
      "开始预测用户1对电影5378的评分...\n",
      "预测出用户1对物品5378的评分：3.16993\n",
      "(1, 5378, 3.17)\n",
      "开始预测用户1对电影87306的评分...\n",
      "预测出用户1对物品87306的评分：3.72900\n",
      "(1, 87306, 3.73)\n",
      "开始预测用户1对电影5388的评分...\n",
      "预测出用户1对物品5388的评分：3.34386\n",
      "(1, 5388, 3.34)\n",
      "开始预测用户1对电影95510的评分...\n",
      "预测出用户1对物品95510的评分：2.85124\n",
      "(1, 95510, 2.85)\n",
      "开始预测用户1对电影5400的评分...\n",
      "预测出用户1对物品5400的评分：2.85330\n",
      "(1, 5400, 2.85)\n",
      "开始预测用户1对电影79132的评分...\n",
      "预测出用户1对物品79132的评分：4.22976\n",
      "(1, 79132, 4.23)\n",
      "开始预测用户1对电影5418的评分...\n",
      "预测出用户1对物品5418的评分：3.72253\n",
      "(1, 5418, 3.72)\n",
      "开始预测用户1对电影5419的评分...\n",
      "预测出用户1对物品5419的评分：2.52701\n",
      "(1, 5419, 2.53)\n",
      "开始预测用户1对电影5444的评分...\n",
      "预测出用户1对物品5444的评分：3.95919\n",
      "(1, 5444, 3.96)\n",
      "开始预测用户1对电影5445的评分...\n",
      "预测出用户1对物品5445的评分：3.58888\n",
      "(1, 5445, 3.59)\n",
      "开始预测用户1对电影5449的评分...\n",
      "预测出用户1对物品5449的评分：2.96857\n",
      "(1, 5449, 2.97)\n",
      "开始预测用户1对电影5459的评分...\n",
      "预测出用户1对物品5459的评分：2.74399\n",
      "(1, 5459, 2.74)\n",
      "开始预测用户1对电影5463的评分...\n",
      "预测出用户1对物品5463的评分：2.48470\n",
      "(1, 5463, 2.48)\n",
      "开始预测用户1对电影5464的评分...\n",
      "预测出用户1对物品5464的评分：3.50519\n",
      "(1, 5464, 3.51)\n",
      "开始预测用户1对电影103772的评分...\n",
      "预测出用户1对物品103772的评分：3.58883\n",
      "(1, 103772, 3.59)\n",
      "开始预测用户1对电影128360的评分...\n",
      "预测出用户1对物品128360的评分：4.14445\n",
      "(1, 128360, 4.14)\n",
      "开始预测用户1对电影5481的评分...\n",
      "预测出用户1对物品5481的评分：2.79117\n",
      "(1, 5481, 2.79)\n",
      "开始预测用户1对电影5502的评分...\n",
      "预测出用户1对物品5502的评分：3.06887\n",
      "(1, 5502, 3.07)\n",
      "开始预测用户1对电影5505的评分...\n",
      "预测出用户1对物品5505的评分：3.48454\n",
      "(1, 5505, 3.48)\n",
      "开始预测用户1对电影62849的评分...\n",
      "预测出用户1对物品62849的评分：3.78733\n",
      "(1, 62849, 3.79)\n",
      "开始预测用户1对电影5507的评分...\n",
      "预测出用户1对物品5507的评分：2.31879\n",
      "(1, 5507, 2.32)\n",
      "开始预测用户1对电影71057的评分...\n",
      "预测出用户1对物品71057的评分：3.74522\n",
      "(1, 71057, 3.75)\n",
      "开始预测用户1对电影5528的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品5528的评分：3.58334\n",
      "(1, 5528, 3.58)\n",
      "开始预测用户1对电影5541的评分...\n",
      "预测出用户1对物品5541的评分：3.14194\n",
      "(1, 5541, 3.14)\n",
      "开始预测用户1对电影79293的评分...\n",
      "预测出用户1对物品79293的评分：2.51583\n",
      "(1, 79293, 2.52)\n",
      "开始预测用户1对电影46530的评分...\n",
      "预测出用户1对物品46530的评分：2.89603\n",
      "(1, 46530, 2.9)\n",
      "开始预测用户1对电影5574的评分...\n",
      "预测出用户1对物品5574的评分：3.18336\n",
      "(1, 5574, 3.18)\n",
      "开始预测用户1对电影5577的评分...\n",
      "预测出用户1对物品5577的评分：3.97012\n",
      "(1, 5577, 3.97)\n",
      "开始预测用户1对电影87520的评分...\n",
      "预测出用户1对物品87520的评分：1.98670\n",
      "(1, 87520, 1.99)\n",
      "开始预测用户1对电影5608的评分...\n",
      "预测出用户1对物品5608的评分：4.09442\n",
      "(1, 5608, 4.09)\n",
      "开始预测用户1对电影5617的评分...\n",
      "预测出用户1对物品5617的评分：4.02025\n",
      "(1, 5617, 4.02)\n",
      "开始预测用户1对电影5618的评分...\n",
      "预测出用户1对物品5618的评分：4.40641\n",
      "(1, 5618, 4.41)\n",
      "开始预测用户1对电影46578的评分...\n",
      "预测出用户1对物品46578的评分：4.15035\n",
      "(1, 46578, 4.15)\n",
      "开始预测用户1对电影5620的评分...\n",
      "预测出用户1对物品5620的评分：3.03161\n",
      "(1, 5620, 3.03)\n",
      "开始预测用户1对电影5630的评分...\n",
      "预测出用户1对物品5630的评分：3.55674\n",
      "(1, 5630, 3.56)\n",
      "开始预测用户1对电影112138的评分...\n",
      "预测出用户1对物品112138的评分：3.74220\n",
      "(1, 112138, 3.74)\n",
      "开始预测用户1对电影5650的评分...\n",
      "预测出用户1对物品5650的评分：3.78399\n",
      "(1, 5650, 3.78)\n",
      "开始预测用户1对电影62999的评分...\n",
      "预测出用户1对物品62999的评分：3.73930\n",
      "(1, 62999, 3.74)\n",
      "开始预测用户1对电影5669的评分...\n",
      "预测出用户1对物品5669的评分：3.81218\n",
      "(1, 5669, 3.81)\n",
      "开始预测用户1对电影5673的评分...\n",
      "预测出用户1对物品5673的评分：3.76873\n",
      "(1, 5673, 3.77)\n",
      "开始预测用户1对电影5679的评分...\n",
      "预测出用户1对物品5679的评分：3.08249\n",
      "(1, 5679, 3.08)\n",
      "开始预测用户1对电影112175的评分...\n",
      "预测出用户1对物品112175的评分：4.34568\n",
      "(1, 112175, 4.35)\n",
      "开始预测用户1对电影112183的评分...\n",
      "预测出用户1对物品112183的评分：3.55897\n",
      "(1, 112183, 3.56)\n",
      "开始预测用户1对电影5690的评分...\n",
      "预测出用户1对物品5690的评分：3.96573\n",
      "(1, 5690, 3.97)\n",
      "开始预测用户1对电影5693的评分...\n",
      "预测出用户1对物品5693的评分：3.18185\n",
      "(1, 5693, 3.18)\n",
      "开始预测用户1对电影71264的评分...\n",
      "预测出用户1对物品71264的评分：4.02935\n",
      "(1, 71264, 4.03)\n",
      "开始预测用户1对电影54881的评分...\n",
      "预测出用户1对物品54881的评分：3.75229\n",
      "(1, 54881, 3.75)\n",
      "开始预测用户1对电影177765的评分...\n",
      "预测出用户1对物品177765的评分：3.63079\n",
      "(1, 177765, 3.63)\n",
      "开始预测用户1对电影63082的评分...\n",
      "预测出用户1对物品63082的评分：3.99287\n",
      "(1, 63082, 3.99)\n",
      "开始预测用户1对电影46723的评分...\n",
      "预测出用户1对物品46723的评分：3.46269\n",
      "(1, 46723, 3.46)\n",
      "开始预测用户1对电影63113的评分...\n",
      "预测出用户1对物品63113的评分：3.65543\n",
      "(1, 63113, 3.66)\n",
      "开始预测用户1对电影5782的评分...\n",
      "预测出用户1对物品5782的评分：4.05999\n",
      "(1, 5782, 4.06)\n",
      "开始预测用户1对电影5785的评分...\n",
      "预测出用户1对物品5785的评分：3.63711\n",
      "(1, 5785, 3.64)\n",
      "开始预测用户1对电影63131的评分...\n",
      "预测出用户1对物品63131的评分：3.77826\n",
      "(1, 63131, 3.78)\n",
      "开始预测用户1对电影5791的评分...\n",
      "预测出用户1对物品5791的评分：3.73505\n",
      "(1, 5791, 3.74)\n",
      "开始预测用户1对电影136864的评分...\n",
      "预测出用户1对物品136864的评分：3.14017\n",
      "(1, 136864, 3.14)\n",
      "开始预测用户1对电影112290的评分...\n",
      "预测出用户1对物品112290的评分：4.30531\n",
      "(1, 112290, 4.31)\n",
      "开始预测用户1对电影5810的评分...\n",
      "预测出用户1对物品5810的评分：3.14828\n",
      "(1, 5810, 3.15)\n",
      "开始预测用户1对电影5812的评分...\n",
      "预测出用户1对物品5812的评分：3.94226\n",
      "(1, 5812, 3.94)\n",
      "开始预测用户1对电影5816的评分...\n",
      "预测出用户1对物品5816的评分：3.63770\n",
      "(1, 5816, 3.64)\n",
      "开始预测用户1对电影54995的评分...\n",
      "预测出用户1对物品54995的评分：3.20091\n",
      "(1, 54995, 3.2)\n",
      "开始预测用户1对电影54997的评分...\n",
      "预测出用户1对物品54997的评分：4.14802\n",
      "(1, 54997, 4.15)\n",
      "开始预测用户1对电影54999的评分...\n",
      "预测出用户1对物品54999的评分：3.02711\n",
      "(1, 54999, 3.03)\n",
      "开始预测用户1对电影79592的评分...\n",
      "预测出用户1对物品79592的评分：3.27508\n",
      "(1, 79592, 3.28)\n",
      "开始预测用户1对电影5872的评分...\n",
      "预测出用户1对物品5872的评分：2.85356\n",
      "(1, 5872, 2.85)\n",
      "开始预测用户1对电影5878的评分...\n",
      "预测出用户1对物品5878的评分：4.17368\n",
      "(1, 5878, 4.17)\n",
      "开始预测用户1对电影5881的评分...\n",
      "预测出用户1对物品5881的评分：2.82226\n",
      "(1, 5881, 2.82)\n",
      "开始预测用户1对电影55052的评分...\n",
      "预测出用户1对物品55052的评分：3.56655\n",
      "(1, 55052, 3.57)\n",
      "开始预测用户1对电影5902的评分...\n",
      "预测出用户1对物品5902的评分：4.28083\n",
      "(1, 5902, 4.28)\n",
      "开始预测用户1对电影5903的评分...\n",
      "预测出用户1对物品5903的评分：3.77064\n",
      "(1, 5903, 3.77)\n",
      "开始预测用户1对电影104211的评分...\n",
      "预测出用户1对物品104211的评分：3.55618\n",
      "(1, 104211, 3.56)\n",
      "开始预测用户1对电影71464的评分...\n",
      "预测出用户1对物品71464的评分：3.46646\n",
      "(1, 71464, 3.47)\n",
      "开始预测用户1对电影104241的评分...\n",
      "预测出用户1对物品104241的评分：3.44886\n",
      "(1, 104241, 3.45)\n",
      "开始预测用户1对电影5943的评分...\n",
      "预测出用户1对物品5943的评分：2.43811\n",
      "(1, 5943, 2.44)\n",
      "开始预测用户1对电影5944的评分...\n",
      "预测出用户1对物品5944的评分：3.15381\n",
      "(1, 5944, 3.15)\n",
      "开始预测用户1对电影5945的评分...\n",
      "预测出用户1对物品5945的评分：3.03809\n",
      "(1, 5945, 3.04)\n",
      "开始预测用户1对电影87869的评分...\n",
      "预测出用户1对物品87869的评分：3.26982\n",
      "(1, 87869, 3.27)\n",
      "开始预测用户1对电影5952的评分...\n",
      "预测出用户1对物品5952的评分：4.06940\n",
      "(1, 5952, 4.07)\n",
      "开始预测用户1对电影5954的评分...\n",
      "预测出用户1对物品5954的评分：3.75109\n",
      "(1, 5954, 3.75)\n",
      "开始预测用户1对电影5956的评分...\n",
      "预测出用户1对物品5956的评分：3.52768\n",
      "(1, 5956, 3.53)\n",
      "开始预测用户1对电影5957的评分...\n",
      "预测出用户1对物品5957的评分：2.84608\n",
      "(1, 5957, 2.85)\n",
      "开始预测用户1对电影55118的评分...\n",
      "预测出用户1对物品55118的评分：3.82875\n",
      "(1, 55118, 3.83)\n",
      "开始预测用户1对电影79695的评分...\n",
      "预测出用户1对物品79695的评分：2.84144\n",
      "(1, 79695, 2.84)\n",
      "开始预测用户1对电影96079的评分...\n",
      "预测出用户1对物品96079的评分：3.79781\n",
      "(1, 96079, 3.8)\n",
      "开始预测用户1对电影5971的评分...\n",
      "预测出用户1对物品5971的评分：4.09783\n",
      "(1, 5971, 4.1)\n",
      "开始预测用户1对电影79702的评分...\n",
      "预测出用户1对物品79702的评分：3.85129\n",
      "(1, 79702, 3.85)\n",
      "开始预测用户1对电影5989的评分...\n",
      "预测出用户1对物品5989的评分：3.94279\n",
      "(1, 5989, 3.94)\n",
      "开始预测用户1对电影5991的评分...\n",
      "预测出用户1对物品5991的评分：3.77367\n",
      "(1, 5991, 3.77)\n",
      "开始预测用户1对电影5992的评分...\n",
      "预测出用户1对物品5992的评分：3.58889\n",
      "(1, 5992, 3.59)\n",
      "开始预测用户1对电影71530的评分...\n",
      "预测出用户1对物品71530的评分：2.68141\n",
      "(1, 71530, 2.68)\n",
      "开始预测用户1对电影5995的评分...\n",
      "预测出用户1对物品5995的评分：4.22815\n",
      "(1, 5995, 4.23)\n",
      "开始预测用户1对电影71535的评分...\n",
      "预测出用户1对物品71535的评分：3.90637\n",
      "(1, 71535, 3.91)\n",
      "开始预测用户1对电影6003的评分...\n",
      "预测出用户1对物品6003的评分：3.48036\n",
      "(1, 6003, 3.48)\n",
      "开始预测用户1对电影46965的评分...\n",
      "预测出用户1对物品46965的评分：2.93725\n",
      "(1, 46965, 2.94)\n",
      "开始预测用户1对电影46970的评分...\n",
      "预测出用户1对物品46970的评分：3.04643\n",
      "(1, 46970, 3.05)\n",
      "开始预测用户1对电影46972的评分...\n",
      "预测出用户1对物品46972的评分：3.21678\n",
      "(1, 46972, 3.22)\n",
      "开始预测用户1对电影6016的评分...\n",
      "预测出用户1对物品6016的评分：3.98050\n",
      "(1, 6016, 3.98)\n",
      "开始预测用户1对电影46976的评分...\n",
      "预测出用户1对物品46976的评分：3.69267\n",
      "(1, 46976, 3.69)\n",
      "开始预测用户1对电影112552的评分...\n",
      "预测出用户1对物品112552的评分：4.03914\n",
      "(1, 112552, 4.04)\n",
      "开始预测用户1对电影6059的评分...\n",
      "预测出用户1对物品6059的评分：3.05552\n",
      "(1, 6059, 3.06)\n",
      "开始预测用户1对电影112556的评分...\n",
      "预测出用户1对物品112556的评分：3.87197\n",
      "(1, 112556, 3.87)\n",
      "开始预测用户1对电影104374的评分...\n",
      "预测出用户1对物品104374的评分：4.22813\n",
      "(1, 104374, 4.23)\n",
      "开始预测用户1对电影55247的评分...\n",
      "预测出用户1对物品55247的评分：3.91460\n",
      "(1, 55247, 3.91)\n",
      "开始预测用户1对电影55269的评分...\n",
      "预测出用户1对物品55269的评分：3.77311\n",
      "(1, 55269, 3.77)\n",
      "开始预测用户1对电影55276的评分...\n",
      "预测出用户1对物品55276的评分：3.62039\n",
      "(1, 55276, 3.62)\n",
      "开始预测用户1对电影112623的评分...\n",
      "预测出用户1对物品112623的评分：3.54887\n",
      "(1, 112623, 3.55)\n",
      "开始预测用户1对电影55282的评分...\n",
      "预测出用户1对物品55282的评分：3.07230\n",
      "(1, 55282, 3.07)\n",
      "开始预测用户1对电影30707的评分...\n",
      "预测出用户1对物品30707的评分：3.77768\n",
      "(1, 30707, 3.78)\n",
      "开始预测用户1对电影55290的评分...\n",
      "预测出用户1对物品55290的评分：3.88996\n",
      "(1, 55290, 3.89)\n",
      "开始预测用户1对电影47099的评分...\n",
      "预测出用户1对物品47099的评分：3.99983\n",
      "(1, 47099, 4.0)\n",
      "开始预测用户1对电影6155的评分...\n",
      "预测出用户1对物品6155的评分：3.25110\n",
      "(1, 6155, 3.25)\n",
      "开始预测用户1对电影6156的评分...\n",
      "预测出用户1对物品6156的评分：3.07911\n",
      "(1, 6156, 3.08)\n",
      "开始预测用户1对电影6157的评分...\n",
      "预测出用户1对物品6157的评分：2.47067\n",
      "(1, 6157, 2.47)\n",
      "开始预测用户1对电影30749的评分...\n",
      "预测出用户1对物品30749的评分：3.94401\n",
      "(1, 30749, 3.94)\n",
      "开始预测用户1对电影6188的评分...\n",
      "预测出用户1对物品6188的评分：3.68742\n",
      "(1, 6188, 3.69)\n",
      "开始预测用户1对电影88125的评分...\n",
      "预测出用户1对物品88125的评分：3.96606\n",
      "(1, 88125, 3.97)\n",
      "开始预测用户1对电影71745的评分...\n",
      "预测出用户1对物品71745的评分：2.69592\n",
      "(1, 71745, 2.7)\n",
      "开始预测用户1对电影88129的评分...\n",
      "预测出用户1对物品88129的评分：3.89436\n",
      "(1, 88129, 3.89)\n",
      "开始预测用户1对电影30793的评分...\n",
      "预测出用户1对物品30793的评分：3.05277\n",
      "(1, 30793, 3.05)\n",
      "开始预测用户1对电影6218的评分...\n",
      "预测出用户1对物品6218的评分：3.24939\n",
      "(1, 6218, 3.25)\n",
      "开始预测用户1对电影88140的评分...\n",
      "预测出用户1对物品88140的评分：3.40874\n",
      "(1, 88140, 3.41)\n",
      "开始预测用户1对电影30810的评分...\n",
      "预测出用户1对物品30810的评分：3.73824\n",
      "(1, 30810, 3.74)\n",
      "开始预测用户1对电影30812的评分...\n",
      "预测出用户1对物品30812的评分：3.49270\n",
      "(1, 30812, 3.49)\n",
      "开始预测用户1对电影30816的评分...\n",
      "预测出用户1对物品30816的评分：3.22884\n",
      "(1, 30816, 3.23)\n",
      "开始预测用户1对电影47200的评分...\n",
      "预测出用户1对物品47200的评分：3.09358\n",
      "(1, 47200, 3.09)\n",
      "开始预测用户1对电影6242的评分...\n",
      "预测出用户1对物品6242的评分：3.58358\n",
      "(1, 6242, 3.58)\n",
      "开始预测用户1对电影88163的评分...\n",
      "预测出用户1对物品88163的评分：3.99106\n",
      "(1, 88163, 3.99)\n",
      "开始预测用户1对电影30822的评分...\n",
      "预测出用户1对物品30822的评分：3.46327\n",
      "(1, 30822, 3.46)\n",
      "开始预测用户1对电影30825的评分...\n",
      "预测出用户1对物品30825的评分：3.20868\n",
      "(1, 30825, 3.21)\n",
      "开始预测用户1对电影6281的评分...\n",
      "预测出用户1对物品6281的评分：2.91068\n",
      "(1, 6281, 2.91)\n",
      "开始预测用户1对电影6283的评分...\n",
      "预测出用户1对物品6283的评分：4.05105\n",
      "(1, 6283, 4.05)\n",
      "开始预测用户1对电影6287的评分...\n",
      "预测出用户1对物品6287的评分：3.08297\n",
      "(1, 6287, 3.08)\n",
      "开始预测用户1对电影55442的评分...\n",
      "预测出用户1对物品55442的评分：4.40322\n",
      "(1, 55442, 4.4)\n",
      "开始预测用户1对电影6294的评分...\n",
      "预测出用户1对物品6294的评分：2.49802\n",
      "(1, 6294, 2.5)\n",
      "开始预测用户1对电影6296的评分...\n",
      "预测出用户1对物品6296的评分：3.51834\n",
      "(1, 6296, 3.52)\n",
      "开始预测用户1对电影6297的评分...\n",
      "预测出用户1对物品6297的评分：3.42652\n",
      "(1, 6297, 3.43)\n",
      "开始预测用户1对电影6323的评分...\n",
      "预测出用户1对物品6323的评分：3.46603\n",
      "(1, 6323, 3.47)\n",
      "开始预测用户1对电影6331的评分...\n",
      "预测出用户1对物品6331的评分：3.77038\n",
      "(1, 6331, 3.77)\n",
      "开始预测用户1对电影6333的评分...\n",
      "预测出用户1对物品6333的评分：3.70884\n",
      "(1, 6333, 3.71)\n",
      "开始预测用户1对电影6350的评分...\n",
      "预测出用户1对物品6350的评分：4.19110\n",
      "(1, 6350, 4.19)\n",
      "开始预测用户1对电影112852的评分...\n",
      "预测出用户1对物品112852的评分：4.12670\n",
      "(1, 112852, 4.13)\n",
      "开始预测用户1对电影6365的评分...\n",
      "预测出用户1对物品6365的评分：3.39926\n",
      "(1, 6365, 3.4)\n",
      "开始预测用户1对电影6373的评分...\n",
      "预测出用户1对物品6373的评分：3.31512\n",
      "(1, 6373, 3.32)\n",
      "开始预测用户1对电影6377的评分...\n",
      "预测出用户1对物品6377的评分：3.88059\n",
      "(1, 6377, 3.88)\n",
      "开始预测用户1对电影6378的评分...\n",
      "预测出用户1对物品6378的评分：3.45711\n",
      "(1, 6378, 3.46)\n",
      "开始预测用户1对电影6383的评分...\n",
      "预测出用户1对物品6383的评分：2.27357\n",
      "(1, 6383, 2.27)\n",
      "开始预测用户1对电影6385的评分...\n",
      "预测出用户1对物品6385的评分：4.21780\n",
      "(1, 6385, 4.22)\n",
      "开始预测用户1对电影39183的评分...\n",
      "预测出用户1对物品39183的评分：3.76479\n",
      "(1, 39183, 3.76)\n",
      "开始预测用户1对电影6440的评分...\n",
      "预测出用户1对物品6440的评分：4.08993\n",
      "(1, 6440, 4.09)\n",
      "开始预测用户1对电影72011的评分...\n",
      "预测出用户1对物品72011的评分：3.81205\n",
      "(1, 72011, 3.81)\n",
      "开始预测用户1对电影96588的评分...\n",
      "预测出用户1对物品96588的评分：3.30205\n",
      "(1, 96588, 3.3)\n",
      "开始预测用户1对电影6482的评分...\n",
      "预测出用户1对物品6482的评分：1.97807\n",
      "(1, 6482, 1.98)\n",
      "开始预测用户1对电影88405的评分...\n",
      "预测出用户1对物品88405的评分：3.03638\n",
      "(1, 88405, 3.04)\n",
      "开始预测用户1对电影80219的评分...\n",
      "预测出用户1对物品80219的评分：3.46484\n",
      "(1, 80219, 3.46)\n",
      "开始预测用户1对电影96610的评分...\n",
      "预测出用户1对物品96610的评分：3.73180\n",
      "(1, 96610, 3.73)\n",
      "开始预测用户1对电影6502的评分...\n",
      "预测出用户1对物品6502的评分：4.12220\n",
      "(1, 6502, 4.12)\n",
      "开始预测用户1对电影6503的评分...\n",
      "预测出用户1对物品6503的评分：2.48282\n",
      "(1, 6503, 2.48)\n",
      "开始预测用户1对电影63859的评分...\n",
      "预测出用户1对物品63859的评分：3.31190\n",
      "(1, 63859, 3.31)\n",
      "开始预测用户1对电影39292的评分...\n",
      "预测出用户1对物品39292的评分：3.70701\n",
      "(1, 39292, 3.71)\n",
      "开始预测用户1对电影63876的评分...\n",
      "预测出用户1对物品63876的评分：3.69847\n",
      "(1, 63876, 3.7)\n",
      "开始预测用户1对电影6534的评分...\n",
      "预测出用户1对物品6534的评分：2.75875\n",
      "(1, 6534, 2.76)\n",
      "开始预测用户1对电影6535的评分...\n",
      "预测出用户1对物品6535的评分：2.01389\n",
      "(1, 6535, 2.01)\n",
      "开始预测用户1对电影6537的评分...\n",
      "预测出用户1对物品6537的评分：2.91685\n",
      "(1, 6537, 2.92)\n",
      "开始预测用户1对电影104841的评分...\n",
      "预测出用户1对物品104841的评分：3.94350\n",
      "(1, 104841, 3.94)\n",
      "开始预测用户1对电影6539的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品6539的评分：3.75563\n",
      "(1, 6539, 3.76)\n",
      "开始预测用户1对电影6541的评分...\n",
      "预测出用户1对物品6541的评分：2.71406\n",
      "(1, 6541, 2.71)\n",
      "开始预测用户1对电影6548的评分...\n",
      "预测出用户1对物品6548的评分：2.97572\n",
      "(1, 6548, 2.98)\n",
      "开始预测用户1对电影6550的评分...\n",
      "预测出用户1对物品6550的评分：2.73172\n",
      "(1, 6550, 2.73)\n",
      "开始预测用户1对电影6552的评分...\n",
      "预测出用户1对物品6552的评分：3.59342\n",
      "(1, 6552, 3.59)\n",
      "开始预测用户1对电影47518的评分...\n",
      "预测出用户1对物品47518的评分：2.43895\n",
      "(1, 47518, 2.44)\n",
      "开始预测用户1对电影6564的评分...\n",
      "预测出用户1对物品6564的评分：2.70786\n",
      "(1, 6564, 2.71)\n",
      "开始预测用户1对电影6565的评分...\n",
      "预测出用户1对物品6565的评分：3.80917\n",
      "(1, 6565, 3.81)\n",
      "开始预测用户1对电影104879的评分...\n",
      "预测出用户1对物品104879的评分：3.85236\n",
      "(1, 104879, 3.85)\n",
      "开始预测用户1对电影6586的评分...\n",
      "预测出用户1对物品6586的评分：2.95458\n",
      "(1, 6586, 2.95)\n",
      "开始预测用户1对电影6593的评分...\n",
      "预测出用户1对物品6593的评分：3.13144\n",
      "(1, 6593, 3.13)\n",
      "开始预测用户1对电影6595的评分...\n",
      "预测出用户1对物品6595的评分：3.06758\n",
      "(1, 6595, 3.07)\n",
      "开始预测用户1对电影104913的评分...\n",
      "预测出用户1对物品104913的评分：4.04174\n",
      "(1, 104913, 4.04)\n",
      "开始预测用户1对电影55765的评分...\n",
      "预测出用户1对物品55765的评分：4.20315\n",
      "(1, 55765, 4.2)\n",
      "开始预测用户1对电影6618的评分...\n",
      "预测出用户1对物品6618的评分：3.79171\n",
      "(1, 6618, 3.79)\n",
      "开始预测用户1对电影6620的评分...\n",
      "预测出用户1对物品6620的评分：3.93727\n",
      "(1, 6620, 3.94)\n",
      "开始预测用户1对电影96737的评分...\n",
      "预测出用户1对物品96737的评分：3.57433\n",
      "(1, 96737, 3.57)\n",
      "开始预测用户1对电影63992的评分...\n",
      "预测出用户1对物品63992的评分：2.07532\n",
      "(1, 63992, 2.08)\n",
      "开始预测用户1对电影47610的评分...\n",
      "预测出用户1对物品47610的评分：3.81210\n",
      "(1, 47610, 3.81)\n",
      "开始预测用户1对电影6659的评分...\n",
      "预测出用户1对物品6659的评分：3.22859\n",
      "(1, 6659, 3.23)\n",
      "开始预测用户1对电影6662的评分...\n",
      "预测出用户1对物品6662的评分：3.53202\n",
      "(1, 6662, 3.53)\n",
      "开始预测用户1对电影55820的评分...\n",
      "预测出用户1对物品55820的评分：3.93774\n",
      "(1, 55820, 3.94)\n",
      "开始预测用户1对电影47629的评分...\n",
      "预测出用户1对物品47629的评分：3.67186\n",
      "(1, 47629, 3.67)\n",
      "开始预测用户1对电影39446的评分...\n",
      "预测出用户1对物品39446的评分：2.59469\n",
      "(1, 39446, 2.59)\n",
      "开始预测用户1对电影72226的评分...\n",
      "预测出用户1对物品72226的评分：4.31825\n",
      "(1, 72226, 4.32)\n",
      "开始预测用户1对电影6708的评分...\n",
      "预测出用户1对物品6708的评分：3.65873\n",
      "(1, 6708, 3.66)\n",
      "开始预测用户1对电影6709的评分...\n",
      "预测出用户1对物品6709的评分：3.19118\n",
      "(1, 6709, 3.19)\n",
      "开始预测用户1对电影96821的评分...\n",
      "预测出用户1对物品96821的评分：4.30417\n",
      "(1, 96821, 4.3)\n",
      "开始预测用户1对电影6711的评分...\n",
      "预测出用户1对物品6711的评分：4.01059\n",
      "(1, 6711, 4.01)\n",
      "开始预测用户1对电影80463的评分...\n",
      "预测出用户1对物品80463的评分：3.95625\n",
      "(1, 80463, 3.96)\n",
      "开始预测用户1对电影6753的评分...\n",
      "预测出用户1对物品6753的评分：3.39679\n",
      "(1, 6753, 3.4)\n",
      "开始预测用户1对电影6754的评分...\n",
      "预测出用户1对物品6754的评分：3.46038\n",
      "(1, 6754, 3.46)\n",
      "开始预测用户1对电影6755的评分...\n",
      "预测出用户1对物品6755的评分：3.34924\n",
      "(1, 6755, 3.35)\n",
      "开始预测用户1对电影80489的评分...\n",
      "预测出用户1对物品80489的评分：4.07589\n",
      "(1, 80489, 4.08)\n",
      "开始预测用户1对电影6764的评分...\n",
      "预测出用户1对物品6764的评分：3.14446\n",
      "(1, 6764, 3.14)\n",
      "开始预测用户1对电影6773的评分...\n",
      "预测出用户1对物品6773的评分：3.51735\n",
      "(1, 6773, 3.52)\n",
      "开始预测用户1对电影137857的评分...\n",
      "预测出用户1对物品137857的评分：3.58682\n",
      "(1, 137857, 3.59)\n",
      "开始预测用户1对电影6787的评分...\n",
      "预测出用户1对物品6787的评分：4.04718\n",
      "(1, 6787, 4.05)\n",
      "开始预测用户1对电影6793的评分...\n",
      "预测出用户1对物品6793的评分：1.91644\n",
      "(1, 6793, 1.92)\n",
      "开始预测用户1对电影6796的评分...\n",
      "预测出用户1对物品6796的评分：3.84104\n",
      "(1, 6796, 3.84)\n",
      "开始预测用户1对电影6807的评分...\n",
      "预测出用户1对物品6807的评分：4.12013\n",
      "(1, 6807, 4.12)\n",
      "开始预测用户1对电影80549的评分...\n",
      "预测出用户1对物品80549的评分：3.66578\n",
      "(1, 80549, 3.67)\n",
      "开始预测用户1对电影88744的评分...\n",
      "预测出用户1对物品88744的评分：3.08193\n",
      "(1, 88744, 3.08)\n",
      "开始预测用户1对电影31410的评分...\n",
      "预测出用户1对物品31410的评分：3.93840\n",
      "(1, 31410, 3.94)\n",
      "开始预测用户1对电影72378的评分...\n",
      "预测出用户1对物品72378的评分：2.53533\n",
      "(1, 72378, 2.54)\n",
      "开始预测用户1对电影6857的评分...\n",
      "预测出用户1对物品6857的评分：3.82732\n",
      "(1, 6857, 3.83)\n",
      "开始预测用户1对电影31433的评分...\n",
      "预测出用户1对物品31433的评分：2.95925\n",
      "(1, 31433, 2.96)\n",
      "开始预测用户1对电影6863的评分...\n",
      "预测出用户1对物品6863的评分：3.34537\n",
      "(1, 6863, 3.35)\n",
      "开始预测用户1对电影6867的评分...\n",
      "预测出用户1对物品6867的评分：3.99095\n",
      "(1, 6867, 3.99)\n",
      "开始预测用户1对电影6870的评分...\n",
      "预测出用户1对物品6870的评分：3.73280\n",
      "(1, 6870, 3.73)\n",
      "开始预测用户1对电影6873的评分...\n",
      "预测出用户1对物品6873的评分：3.10169\n",
      "(1, 6873, 3.1)\n",
      "开始预测用户1对电影6874的评分...\n",
      "预测出用户1对物品6874的评分：3.98951\n",
      "(1, 6874, 3.99)\n",
      "开始预测用户1对电影6879的评分...\n",
      "预测出用户1对物品6879的评分：3.57025\n",
      "(1, 6879, 3.57)\n",
      "开始预测用户1对电影6888的评分...\n",
      "预测出用户1对物品6888的评分：2.09869\n",
      "(1, 6888, 2.1)\n",
      "开始预测用户1对电影88810的评分...\n",
      "预测出用户1对物品88810的评分：3.68792\n",
      "(1, 88810, 3.69)\n",
      "开始预测用户1对电影6934的评分...\n",
      "预测出用户1对物品6934的评分：3.27711\n",
      "(1, 6934, 3.28)\n",
      "开始预测用户1对电影6936的评分...\n",
      "预测出用户1对物品6936的评分：3.67608\n",
      "(1, 6936, 3.68)\n",
      "开始预测用户1对电影6942的评分...\n",
      "预测出用户1对物品6942的评分：3.80658\n",
      "(1, 6942, 3.81)\n",
      "开始预测用户1对电影6944的评分...\n",
      "预测出用户1对物品6944的评分：3.49524\n",
      "(1, 6944, 3.5)\n",
      "开始预测用户1对电影6947的评分...\n",
      "预测出用户1对物品6947的评分：3.57811\n",
      "(1, 6947, 3.58)\n",
      "开始预测用户1对电影6953的评分...\n",
      "预测出用户1对物品6953的评分：3.40502\n",
      "(1, 6953, 3.41)\n",
      "开始预测用户1对电影6957的评分...\n",
      "预测出用户1对物品6957的评分：3.22250\n",
      "(1, 6957, 3.22)\n",
      "开始预测用户1对电影138036的评分...\n",
      "预测出用户1对物品138036的评分：3.91317\n",
      "(1, 138036, 3.91)\n",
      "开始预测用户1对电影6979的评分...\n",
      "预测出用户1对物品6979的评分：3.10575\n",
      "(1, 6979, 3.11)\n",
      "开始预测用户1对电影6993的评分...\n",
      "预测出用户1对物品6993的评分：3.82802\n",
      "(1, 6993, 3.83)\n",
      "开始预测用户1对电影56145的评分...\n",
      "预测出用户1对物品56145的评分：3.15889\n",
      "(1, 56145, 3.16)\n",
      "开始预测用户1对电影56152的评分...\n",
      "预测出用户1对物品56152的评分：3.49252\n",
      "(1, 56152, 3.49)\n",
      "开始预测用户1对电影7004的评分...\n",
      "预测出用户1对物品7004的评分：2.74394\n",
      "(1, 7004, 2.74)\n",
      "开始预测用户1对电影56171的评分...\n",
      "预测出用户1对物品56171的评分：3.08649\n",
      "(1, 56171, 3.09)\n",
      "开始预测用户1对电影7022的评分...\n",
      "预测出用户1对物品7022的评分：3.94114\n",
      "(1, 7022, 3.94)\n",
      "开始预测用户1对电影56174的评分...\n",
      "预测出用户1对物品56174的评分：3.36026\n",
      "(1, 56174, 3.36)\n",
      "开始预测用户1对电影47997的评分...\n",
      "预测出用户1对物品47997的评分：3.70979\n",
      "(1, 47997, 3.71)\n",
      "开始预测用户1对电影7046的评分...\n",
      "预测出用户1对物品7046的评分：2.64384\n",
      "(1, 7046, 2.64)\n",
      "开始预测用户1对电影31658的评分...\n",
      "预测出用户1对物品31658的评分：4.09935\n",
      "(1, 31658, 4.1)\n",
      "开始预测用户1对电影48043的评分...\n",
      "预测出用户1对物品48043的评分：3.71644\n",
      "(1, 48043, 3.72)\n",
      "开始预测用户1对电影7090的评分...\n",
      "预测出用户1对物品7090的评分：4.04504\n",
      "(1, 7090, 4.05)\n",
      "开始预测用户1对电影7099的评分...\n",
      "预测出用户1对物品7099的评分：4.20541\n",
      "(1, 7099, 4.21)\n",
      "开始预测用户1对电影72641的评分...\n",
      "预测出用户1对物品72641的评分：3.78598\n",
      "(1, 72641, 3.79)\n",
      "开始预测用户1对电影31685的评分...\n",
      "预测出用户1对物品31685的评分：3.18481\n",
      "(1, 31685, 3.18)\n",
      "开始预测用户1对电影97225的评分...\n",
      "预测出用户1对物品97225的评分：3.19729\n",
      "(1, 97225, 3.2)\n",
      "开始预测用户1对电影31696的评分...\n",
      "预测出用户1对物品31696的评分：3.36542\n",
      "(1, 31696, 3.37)\n",
      "开始预测用户1对电影48082的评分...\n",
      "预测出用户1对物品48082的评分：3.97459\n",
      "(1, 48082, 3.97)\n",
      "开始预测用户1对电影7143的评分...\n",
      "预测出用户1对物品7143的评分：3.84661\n",
      "(1, 7143, 3.85)\n",
      "开始预测用户1对电影7147的评分...\n",
      "预测出用户1对物品7147的评分：3.84177\n",
      "(1, 7147, 3.84)\n",
      "开始预测用户1对电影7149的评分...\n",
      "预测出用户1对物品7149的评分：3.42130\n",
      "(1, 7149, 3.42)\n",
      "开始预测用户1对电影7151的评分...\n",
      "预测出用户1对物品7151的评分：3.63348\n",
      "(1, 7151, 3.63)\n",
      "开始预测用户1对电影7153的评分...\n",
      "预测出用户1对物品7153的评分：4.21516\n",
      "(1, 7153, 4.22)\n",
      "开始预测用户1对电影7156的评分...\n",
      "预测出用户1对物品7156的评分：4.26288\n",
      "(1, 7156, 4.26)\n",
      "开始预测用户1对电影7160的评分...\n",
      "预测出用户1对物品7160的评分：3.31812\n",
      "(1, 7160, 3.32)\n",
      "开始预测用户1对电影7162的评分...\n",
      "预测出用户1对物品7162的评分：3.01996\n",
      "(1, 7162, 3.02)\n",
      "开始预测用户1对电影7163的评分...\n",
      "预测出用户1对物品7163的评分：2.97455\n",
      "(1, 7163, 2.97)\n",
      "开始预测用户1对电影7173的评分...\n",
      "预测出用户1对物品7173的评分：3.25838\n",
      "(1, 7173, 3.26)\n",
      "开始预测用户1对电影80906的评分...\n",
      "预测出用户1对物品80906的评分：4.69503\n",
      "(1, 80906, 4.7)\n",
      "开始预测用户1对电影97304的评分...\n",
      "预测出用户1对物品97304的评分：4.23866\n",
      "(1, 97304, 4.24)\n",
      "开始预测用户1对电影97306的评分...\n",
      "预测出用户1对物品97306的评分：3.51793\n",
      "(1, 97306, 3.52)\n",
      "开始预测用户1对电影105504的评分...\n",
      "预测出用户1对物品105504的评分：4.10075\n",
      "(1, 105504, 4.1)\n",
      "开始预测用户1对电影72737的评分...\n",
      "预测出用户1对物品72737的评分：3.91170\n",
      "(1, 72737, 3.91)\n",
      "开始预测用户1对电影56367的评分...\n",
      "预测出用户1对物品56367的评分：4.03294\n",
      "(1, 56367, 4.03)\n",
      "开始预测用户1对电影7247的评分...\n",
      "预测出用户1对物品7247的评分：3.10928\n",
      "(1, 7247, 3.11)\n",
      "开始预测用户1对电影7254的评分...\n",
      "预测出用户1对物品7254的评分：3.54715\n",
      "(1, 7254, 3.55)\n",
      "开始预测用户1对电影7265的评分...\n",
      "预测出用户1对物品7265的评分：3.74557\n",
      "(1, 7265, 3.75)\n",
      "开始预测用户1对电影64614的评分...\n",
      "预测出用户1对物品64614的评分：4.06793\n",
      "(1, 64614, 4.07)\n",
      "开始预测用户1对电影7293的评分...\n",
      "预测出用户1对物品7293的评分：3.57540\n",
      "(1, 7293, 3.58)\n",
      "开始预测用户1对电影31878的评分...\n",
      "预测出用户1对物品31878的评分：3.81237\n",
      "(1, 31878, 3.81)\n",
      "开始预测用户1对电影7317的评分...\n",
      "预测出用户1对物品7317的评分：2.77396\n",
      "(1, 7317, 2.77)\n",
      "开始预测用户1对电影7318的评分...\n",
      "预测出用户1对物品7318的评分：2.52784\n",
      "(1, 7318, 2.53)\n",
      "开始预测用户1对电影7323的评分...\n",
      "预测出用户1对物品7323的评分：3.47404\n",
      "(1, 7323, 3.47)\n",
      "开始预测用户1对电影7324的评分...\n",
      "预测出用户1对物品7324的评分：3.28857\n",
      "(1, 7324, 3.29)\n",
      "开始预测用户1对电影7325的评分...\n",
      "预测出用户1对物品7325的评分：3.39382\n",
      "(1, 7325, 3.39)\n",
      "开始预测用户1对电影48304的评分...\n",
      "预测出用户1对物品48304的评分：3.53675\n",
      "(1, 48304, 3.54)\n",
      "开始预测用户1对电影7346的评分...\n",
      "预测出用户1对物品7346的评分：2.71025\n",
      "(1, 7346, 2.71)\n",
      "开始预测用户1对电影7347的评分...\n",
      "预测出用户1对物品7347的评分：3.21041\n",
      "(1, 7347, 3.21)\n",
      "开始预测用户1对电影7360的评分...\n",
      "预测出用户1对物品7360的评分：3.94975\n",
      "(1, 7360, 3.95)\n",
      "开始预测用户1对电影7361的评分...\n",
      "预测出用户1对物品7361的评分：4.28907\n",
      "(1, 7361, 4.29)\n",
      "开始预测用户1对电影7367的评分...\n",
      "预测出用户1对物品7367的评分：2.27481\n",
      "(1, 7367, 2.27)\n",
      "开始预测用户1对电影187593的评分...\n",
      "预测出用户1对物品187593的评分：3.61947\n",
      "(1, 187593, 3.62)\n",
      "开始预测用户1对电影7371的评分...\n",
      "预测出用户1对物品7371的评分：3.92682\n",
      "(1, 7371, 3.93)\n",
      "开始预测用户1对电影64716的评分...\n",
      "预测出用户1对物品64716的评分：4.18396\n",
      "(1, 64716, 4.18)\n",
      "开始预测用户1对电影7373的评分...\n",
      "预测出用户1对物品7373的评分：3.36892\n",
      "(1, 7373, 3.37)\n",
      "开始预测用户1对电影7387的评分...\n",
      "预测出用户1对物品7387的评分：3.99430\n",
      "(1, 7387, 3.99)\n",
      "开始预测用户1对电影48385的评分...\n",
      "预测出用户1对物品48385的评分：3.52981\n",
      "(1, 48385, 3.53)\n",
      "开始预测用户1对电影48394的评分...\n",
      "预测出用户1对物品48394的评分：3.79697\n",
      "(1, 48394, 3.8)\n",
      "开始预测用户1对电影56587的评分...\n",
      "预测出用户1对物品56587的评分：3.63878\n",
      "(1, 56587, 3.64)\n",
      "开始预测用户1对电影7438的评分...\n",
      "预测出用户1对物品7438的评分：3.98120\n",
      "(1, 7438, 3.98)\n",
      "开始预测用户1对电影7439的评分...\n",
      "预测出用户1对物品7439的评分：3.19767\n",
      "(1, 7439, 3.2)\n",
      "开始预测用户1对电影7444的评分...\n",
      "预测出用户1对物品7444的评分：3.02532\n",
      "(1, 7444, 3.03)\n",
      "开始预测用户1对电影7445的评分...\n",
      "预测出用户1对物品7445的评分：3.30604\n",
      "(1, 7445, 3.31)\n",
      "开始预测用户1对电影7451的评分...\n",
      "预测出用户1对物品7451的评分：3.74654\n",
      "(1, 7451, 3.75)\n",
      "开始预测用户1对电影7454的评分...\n",
      "预测出用户1对物品7454的评分：2.85956\n",
      "(1, 7454, 2.86)\n",
      "开始预测用户1对电影32031的评分...\n",
      "预测出用户1对物品32031的评分：3.38657\n",
      "(1, 32031, 3.39)\n",
      "开始预测用户1对电影7458的评分...\n",
      "预测出用户1对物品7458的评分：3.42859\n",
      "(1, 7458, 3.43)\n",
      "开始预测用户1对电影72998的评分...\n",
      "预测出用户1对物品72998的评分：3.76434\n",
      "(1, 72998, 3.76)\n",
      "开始预测用户1对电影73017的评分...\n",
      "预测出用户1对物品73017的评分：3.97097\n",
      "(1, 73017, 3.97)\n",
      "开始预测用户1对电影7482的评分...\n",
      "预测出用户1对物品7482的评分：4.00004\n",
      "(1, 7482, 4.0)\n",
      "开始预测用户1对电影64839的评分...\n",
      "预测出用户1对物品64839的评分：3.84254\n",
      "(1, 64839, 3.84)\n",
      "开始预测用户1对电影81229的评分...\n",
      "预测出用户1对物品81229的评分：3.09540\n",
      "(1, 81229, 3.1)\n",
      "开始预测用户1对电影40278的评分...\n",
      "预测出用户1对物品40278的评分：3.74139\n",
      "(1, 40278, 3.74)\n",
      "开始预测用户1对电影105844的评分...\n",
      "预测出用户1对物品105844的评分：3.85933\n",
      "(1, 105844, 3.86)\n",
      "开始预测用户1对电影89470的评分...\n",
      "预测出用户1对物品89470的评分：3.79674\n",
      "(1, 89470, 3.8)\n",
      "开始预测用户1对电影48516的评分...\n",
      "预测出用户1对物品48516的评分：4.43904\n",
      "(1, 48516, 4.44)\n",
      "开始预测用户1对电影7569的评分...\n",
      "预测出用户1对物品7569的评分：3.55541\n",
      "(1, 7569, 3.56)\n",
      "开始预测用户1对电影89492的评分...\n",
      "预测出用户1对物品89492的评分：3.88814\n",
      "(1, 89492, 3.89)\n",
      "开始预测用户1对电影56757的评分...\n",
      "预测出用户1对物品56757的评分：3.74765\n",
      "(1, 56757, 3.75)\n",
      "开始预测用户1对电影64957的评分...\n",
      "预测出用户1对物品64957的评分：3.67481\n",
      "(1, 64957, 3.67)\n",
      "开始预测用户1对电影56775的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品56775的评分：2.87588\n",
      "(1, 56775, 2.88)\n",
      "开始预测用户1对电影64969的评分...\n",
      "预测出用户1对物品64969的评分：3.82177\n",
      "(1, 64969, 3.82)\n",
      "开始预测用户1对电影56782的评分...\n",
      "预测出用户1对物品56782的评分：4.13525\n",
      "(1, 56782, 4.14)\n",
      "开始预测用户1对电影64983的评分...\n",
      "预测出用户1对物品64983的评分：3.44609\n",
      "(1, 64983, 3.45)\n",
      "开始预测用户1对电影97752的评分...\n",
      "预测出用户1对物品97752的评分：3.69199\n",
      "(1, 97752, 3.69)\n",
      "开始预测用户1对电影114180的评分...\n",
      "预测出用户1对物品114180的评分：2.95978\n",
      "(1, 114180, 2.96)\n",
      "开始预测用户1对电影106002的评分...\n",
      "预测出用户1对物品106002的评分：3.64253\n",
      "(1, 106002, 3.64)\n",
      "开始预测用户1对电影65088的评分...\n",
      "预测出用户1对物品65088的评分：3.51018\n",
      "(1, 65088, 3.51)\n",
      "开始预测用户1对电影106072的评分...\n",
      "预测出用户1对物品106072的评分：3.22513\n",
      "(1, 106072, 3.23)\n",
      "开始预测用户1对电影48738的评分...\n",
      "预测出用户1对物品48738的评分：4.08159\n",
      "(1, 48738, 4.08)\n",
      "开始预测用户1对电影73321的评分...\n",
      "预测出用户1对物品73321的评分：3.11066\n",
      "(1, 73321, 3.11)\n",
      "开始预测用户1对电影179819的评分...\n",
      "预测出用户1对物品179819的评分：3.98105\n",
      "(1, 179819, 3.98)\n",
      "开始预测用户1对电影56941的评分...\n",
      "预测出用户1对物品56941的评分：3.62717\n",
      "(1, 56941, 3.63)\n",
      "开始预测用户1对电影106100的评分...\n",
      "预测出用户1对物品106100的评分：4.39311\n",
      "(1, 106100, 4.39)\n",
      "开始预测用户1对电影56949的评分...\n",
      "预测出用户1对物品56949的评分：3.37541\n",
      "(1, 56949, 3.38)\n",
      "开始预测用户1对电影97913的评分...\n",
      "预测出用户1对物品97913的评分：3.85388\n",
      "(1, 97913, 3.85)\n",
      "开始预测用户1对电影97921的评分...\n",
      "预测出用户1对物品97921的评分：3.73656\n",
      "(1, 97921, 3.74)\n",
      "开始预测用户1对电影48774的评分...\n",
      "预测出用户1对物品48774的评分：4.00105\n",
      "(1, 48774, 4.0)\n",
      "开始预测用户1对电影40583的评分...\n",
      "预测出用户1对物品40583的评分：3.44999\n",
      "(1, 40583, 3.45)\n",
      "开始预测用户1对电影48780的评分...\n",
      "预测出用户1对物品48780的评分：4.01138\n",
      "(1, 48780, 4.01)\n",
      "开始预测用户1对电影48783的评分...\n",
      "预测出用户1对物品48783的评分：3.56455\n",
      "(1, 48783, 3.56)\n",
      "开始预测用户1对电影89745的评分...\n",
      "预测出用户1对物品89745的评分：3.95735\n",
      "(1, 89745, 3.96)\n",
      "开始预测用户1对电影97938的评分...\n",
      "预测出用户1对物品97938的评分：4.06190\n",
      "(1, 97938, 4.06)\n",
      "开始预测用户1对电影81562的评分...\n",
      "预测出用户1对物品81562的评分：4.09065\n",
      "(1, 81562, 4.09)\n",
      "开始预测用户1对电影81564的评分...\n",
      "预测出用户1对物品81564的评分：3.61265\n",
      "(1, 81564, 3.61)\n",
      "开始预测用户1对电影89774的评分...\n",
      "预测出用户1对物品89774的评分：4.05995\n",
      "(1, 89774, 4.06)\n",
      "开始预测用户1对电影40629的评分...\n",
      "预测出用户1对物品40629的评分：3.14695\n",
      "(1, 40629, 3.15)\n",
      "开始预测用户1对电影81591的评分...\n",
      "预测出用户1对物品81591的评分：3.73819\n",
      "(1, 81591, 3.74)\n",
      "开始预测用户1对电影65230的评分...\n",
      "预测出用户1对物品65230的评分：3.34674\n",
      "(1, 65230, 3.35)\n",
      "开始预测用户1对电影48877的评分...\n",
      "预测出用户1对物品48877的评分：3.26341\n",
      "(1, 48877, 3.26)\n",
      "开始预测用户1对电影65261的评分...\n",
      "预测出用户1对物品65261的评分：4.62583\n",
      "(1, 65261, 4.63)\n",
      "开始预测用户1对电影89864的评分...\n",
      "预测出用户1对物品89864的评分：3.91506\n",
      "(1, 89864, 3.92)\n",
      "开始预测用户1对电影40732的评分...\n",
      "预测出用户1对物品40732的评分：3.48216\n",
      "(1, 40732, 3.48)\n",
      "开始预测用户1对电影89904的评分...\n",
      "预测出用户1对物品89904的评分：3.94254\n",
      "(1, 89904, 3.94)\n",
      "开始预测用户1对电影32587的评分...\n",
      "预测出用户1对物品32587的评分：3.95489\n",
      "(1, 32587, 3.95)\n",
      "开始预测用户1对电影40815的评分...\n",
      "预测出用户1对物品40815的评分：3.82129\n",
      "(1, 40815, 3.82)\n",
      "开始预测用户1对电影40819的评分...\n",
      "预测出用户1对物品40819的评分：3.76388\n",
      "(1, 40819, 3.76)\n",
      "开始预测用户1对电影81834的评分...\n",
      "预测出用户1对物品81834的评分：4.08631\n",
      "(1, 81834, 4.09)\n",
      "开始预测用户1对电影81845的评分...\n",
      "预测出用户1对物品81845的评分：4.10551\n",
      "(1, 81845, 4.11)\n",
      "开始预测用户1对电影81847的评分...\n",
      "预测出用户1对物品81847的评分：4.07352\n",
      "(1, 81847, 4.07)\n",
      "开始预测用户1对电影98243的评分...\n",
      "预测出用户1对物品98243的评分：4.25340\n",
      "(1, 98243, 4.25)\n",
      "开始预测用户1对电影114662的评分...\n",
      "预测出用户1对物品114662的评分：4.00647\n",
      "(1, 114662, 4.01)\n",
      "开始预测用户1对电影106487的评分...\n",
      "预测出用户1对物品106487的评分：3.44157\n",
      "(1, 106487, 3.44)\n",
      "开始预测用户1对电影3255的评分...\n",
      "预测出用户1对物品3255的评分：3.36496\n",
      "(1, 3255, 3.36)\n"
     ]
    }
   ],
   "source": [
    "def predict_all(uid,rating_matrix,user_similar,filter_rule = None):\n",
    "    '''\n",
    "    预测全部评分，并可依据条件进行前置过滤\n",
    "    :param uid:用户ID\n",
    "    :param rating_matrix:用户-物品打分表\n",
    "    :param user_similar:用户两两间的相似度\n",
    "    :param filter_rule:过滤规则，\"unhot\",\"rated\",[\"unhot\",\"rated\"],None\n",
    "    :return:生成器，逐个返回\n",
    "    '''\n",
    "    if not filter_rule:\n",
    "        item_ids = rating_matrix.columns\n",
    "    elif isinstance(filter_rule,str) and filter_rule == \"unhot\":\n",
    "        #统计每部电影的评分数 ，一列列统计,评分数大于10个\n",
    "        count = rating_matrix.count()\n",
    "        item_ids = count.where(count>10).dropna().index\n",
    "    elif isinstance(filter_rule,str) and filter_rule == \"rated\":\n",
    "        #找到用户没有打过分的电影，打过分的电影范围在1-5，小于6的都是打过分的\n",
    "        user_rating = rating_matrix.loc[uid]\n",
    "        _ = user_rating<6\n",
    "        item_ids = _.where(_==False).dropna().index\n",
    "    elif isinstance(filter_rule,list) and set(filter_rule) == set([\"unhot\",\"rated\"]):\n",
    "        count = rating_matrix.count()\n",
    "        ids1 = count.where(count>10).dropna().index\n",
    "        \n",
    "        user_rating = rating_matrix.loc[uid]\n",
    "        _ = user_rating<6\n",
    "        ids2 = _.where(_==False).dropna().index\n",
    "        \n",
    "        item_ids = set(ids1)&set(ids2)\n",
    "    else:\n",
    "        raise Exception(\"无效的过滤参数\")\n",
    "        \n",
    "    for iid in item_ids:\n",
    "        try:\n",
    "            rating = predict(uid,iid,rating_matrix,user_similar)\n",
    "        except Exception as e:\n",
    "            print(e)\n",
    "        else:\n",
    "            yield uid,iid,rating\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    rating_matrix = load_data(DATA_PATH)\n",
    "    user_similar = compute_pearson_similarity(rating_matrix,based=\"user\")\n",
    "    for result in predict_all(1,rating_matrix,user_similar,filter_rule=[\"unhot\",\"rated\"]):\n",
    "        print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始加载数据...\n",
      "加载缓存中...\n",
      "从缓存中加载数据完毕...\n",
      "从缓存中加载用户相似度矩阵\n",
      "相似度矩阵处理完毕\n",
      "开始预测用户1对电影2的评分...\n",
      "预测出用户1对物品2的评分：3.38072\n",
      "开始预测用户1对电影122882的评分...\n",
      "预测出用户1对物品122882的评分：3.73712\n",
      "开始预测用户1对电影5的评分...\n",
      "预测出用户1对物品5的评分：3.09120\n",
      "开始预测用户1对电影122886的评分...\n",
      "预测出用户1对物品122886的评分：3.94512\n",
      "开始预测用户1对电影7的评分...\n",
      "预测出用户1对物品7的评分：3.22490\n",
      "开始预测用户1对电影9的评分...\n",
      "预测出用户1对物品9的评分：2.58540\n",
      "开始预测用户1对电影10的评分...\n",
      "预测出用户1对物品10的评分：3.41075\n",
      "开始预测用户1对电影11的评分...\n",
      "预测出用户1对物品11的评分：3.68289\n",
      "开始预测用户1对电影12的评分...\n",
      "预测出用户1对物品12的评分：2.49328\n",
      "开始预测用户1对电影81932的评分...\n",
      "预测出用户1对物品81932的评分：3.76774\n",
      "开始预测用户1对电影14的评分...\n",
      "预测出用户1对物品14的评分：4.22911\n",
      "开始预测用户1对电影15的评分...\n",
      "预测出用户1对物品15的评分：2.79375\n",
      "开始预测用户1对电影16的评分...\n",
      "预测出用户1对物品16的评分：3.98431\n",
      "开始预测用户1对电影17的评分...\n",
      "预测出用户1对物品17的评分：3.88149\n",
      "开始预测用户1对电影18的评分...\n",
      "预测出用户1对物品18的评分：3.60734\n",
      "开始预测用户1对电影19的评分...\n",
      "预测出用户1对物品19的评分：2.77037\n",
      "开始预测用户1对电影20的评分...\n",
      "预测出用户1对物品20的评分：2.89641\n",
      "开始预测用户1对电影21的评分...\n",
      "预测出用户1对物品21的评分：3.48757\n",
      "开始预测用户1对电影22的评分...\n",
      "预测出用户1对物品22的评分：2.89508\n",
      "开始预测用户1对电影23的评分...\n",
      "预测出用户1对物品23的评分：3.15681\n",
      "开始预测用户1对电影24的评分...\n",
      "预测出用户1对物品24的评分：3.00238\n",
      "开始预测用户1对电影25的评分...\n",
      "预测出用户1对物品25的评分：3.78110\n",
      "开始预测用户1对电影26的评分...\n",
      "预测出用户1对物品26的评分：3.45840\n",
      "开始预测用户1对电影57368的评分...\n",
      "预测出用户1对物品57368的评分：3.24651\n",
      "开始预测用户1对电影28的评分...\n",
      "预测出用户1对物品28的评分：4.38234\n",
      "开始预测用户1对电影29的评分...\n",
      "预测出用户1对物品29的评分：4.18804\n",
      "开始预测用户1对电影122904的评分...\n",
      "预测出用户1对物品122904的评分：3.99608\n",
      "开始预测用户1对电影31的评分...\n",
      "预测出用户1对物品31的评分：3.10464\n",
      "开始预测用户1对电影32的评分...\n",
      "预测出用户1对物品32的评分：4.02149\n",
      "开始预测用户1对电影122906的评分...\n",
      "预测出用户1对物品122906的评分：4.29098\n",
      "开始预测用户1对电影34的评分...\n",
      "预测出用户1对物品34的评分：3.62297\n",
      "开始预测用户1对电影122912的评分...\n",
      "预测出用户1对物品122912的评分：3.61408\n",
      "开始预测用户1对电影36的评分...\n",
      "预测出用户1对物品36的评分：3.85436\n",
      "开始预测用户1对电影8228的评分...\n",
      "预测出用户1对物品8228的评分：3.70437\n",
      "开始预测用户1对电影122916的评分...\n",
      "预测出用户1对物品122916的评分：3.94043\n",
      "开始预测用户1对电影39的评分...\n",
      "预测出用户1对物品39的评分：3.16330\n",
      "开始预测用户1对电影122918的评分...\n",
      "预测出用户1对物品122918的评分：4.20625\n",
      "开始预测用户1对电影41的评分...\n",
      "预测出用户1对物品41的评分：3.56913\n",
      "开始预测用户1对电影122920的评分...\n",
      "预测出用户1对物品122920的评分：3.56979\n",
      "开始预测用户1对电影122922的评分...\n",
      "预测出用户1对物品122922的评分：3.60917\n",
      "开始预测用户1对电影44的评分...\n",
      "预测出用户1对物品44的评分：2.33174\n",
      "开始预测用户1对电影45的评分...\n",
      "预测出用户1对物品45的评分：3.38128\n",
      "开始预测用户1对电影46的评分...\n",
      "预测出用户1对物品46的评分：2.62097\n",
      "开始预测用户1对电影122924的评分...\n",
      "预测出用户1对物品122924的评分：3.24646\n",
      "开始预测用户1对电影48的评分...\n",
      "预测出用户1对物品48的评分：3.07192\n",
      "开始预测用户1对电影122926的评分...\n",
      "预测出用户1对物品122926的评分：4.20248\n",
      "开始预测用户1对电影52的评分...\n",
      "预测出用户1对物品52的评分：3.72700\n",
      "开始预测用户1对电影58的评分...\n",
      "预测出用户1对物品58的评分：4.49235\n",
      "开始预测用户1对电影60的评分...\n",
      "预测出用户1对物品60的评分：2.86828\n",
      "开始预测用户1对电影62的评分...\n",
      "预测出用户1对物品62的评分：3.81136\n",
      "开始预测用户1对电影65的评分...\n",
      "预测出用户1对物品65的评分：2.39166\n",
      "开始预测用户1对电影69的评分...\n",
      "预测出用户1对物品69的评分：3.69686\n",
      "开始预测用户1对电影73的评分...\n",
      "预测出用户1对物品73的评分：3.67925\n",
      "开始预测用户1对电影76的评分...\n",
      "预测出用户1对物品76的评分：2.96966\n",
      "开始预测用户1对电影79的评分...\n",
      "预测出用户1对物品79的评分：2.27561\n",
      "开始预测用户1对电影81的评分...\n",
      "预测出用户1对物品81的评分：3.14430\n",
      "开始预测用户1对电影86的评分...\n",
      "预测出用户1对物品86的评分：3.64668\n",
      "开始预测用户1对电影88的评分...\n",
      "预测出用户1对物品88的评分：3.09485\n",
      "开始预测用户1对电影95的评分...\n",
      "预测出用户1对物品95的评分：2.67317\n",
      "开始预测用户1对电影100的评分...\n",
      "预测出用户1对物品100的评分：2.41417\n",
      "开始预测用户1对电影104的评分...\n",
      "预测出用户1对物品104的评分：3.50745\n",
      "开始预测用户1对电影105的评分...\n",
      "预测出用户1对物品105的评分：3.35073\n",
      "开始预测用户1对电影107的评分...\n",
      "预测出用户1对物品107的评分：3.10349\n",
      "开始预测用户1对电影111的评分...\n",
      "预测出用户1对物品111的评分：3.98511\n",
      "开始预测用户1对电影112的评分...\n",
      "预测出用户1对物品112的评分：3.47990\n",
      "开始预测用户1对电影49272的评分...\n",
      "预测出用户1对物品49272的评分：3.83615\n",
      "开始预测用户1对电影139385的评分...\n",
      "预测出用户1对物品139385的评分：4.09582\n",
      "开始预测用户1对电影49274的评分...\n",
      "预测出用户1对物品49274的评分：3.08514\n",
      "开始预测用户1对电影122的评分...\n",
      "预测出用户1对物品122的评分：2.81646\n",
      "开始预测用户1对电影125的评分...\n",
      "预测出用户1对物品125的评分：3.49921\n",
      "开始预测用户1对电影49278的评分...\n",
      "预测出用户1对物品49278的评分：3.11851\n",
      "开始预测用户1对电影49286的评分...\n",
      "预测出用户1对物品49286的评分：3.14960\n",
      "开始预测用户1对电影135的评分...\n",
      "预测出用户1对物品135的评分：2.38569\n",
      "开始预测用户1对电影140的评分...\n",
      "预测出用户1对物品140的评分：3.62182\n",
      "开始预测用户1对电影141的评分...\n",
      "预测出用户1对物品141的评分：3.40046\n",
      "开始预测用户1对电影144的评分...\n",
      "预测出用户1对物品144的评分：3.50307\n",
      "开始预测用户1对电影145的评分...\n",
      "预测出用户1对物品145的评分：3.38620\n",
      "开始预测用户1对电影147的评分...\n",
      "预测出用户1对物品147的评分：3.54310\n",
      "开始预测用户1对电影150的评分...\n",
      "预测出用户1对物品150的评分：3.81256\n",
      "开始预测用户1对电影153的评分...\n",
      "预测出用户1对物品153的评分：2.87531\n",
      "开始预测用户1对电影154的评分...\n",
      "预测出用户1对物品154的评分：4.00592\n",
      "开始预测用户1对电影158的评分...\n",
      "预测出用户1对物品158的评分：2.43721\n",
      "开始预测用户1对电影159的评分...\n",
      "预测出用户1对物品159的评分：2.31297\n",
      "开始预测用户1对电影160的评分...\n",
      "预测出用户1对物品160的评分：2.71746\n",
      "开始预测用户1对电影161的评分...\n",
      "预测出用户1对物品161的评分：3.44194\n",
      "开始预测用户1对电影162的评分...\n",
      "预测出用户1对物品162的评分：4.24213\n",
      "开始预测用户1对电影164的评分...\n",
      "预测出用户1对物品164的评分：2.56666\n",
      "开始预测用户1对电影165的评分...\n",
      "预测出用户1对物品165的评分：3.43946\n",
      "开始预测用户1对电影168的评分...\n",
      "预测出用户1对物品168的评分：3.20128\n",
      "开始预测用户1对电影8360的评分...\n",
      "预测出用户1对物品8360的评分：3.49763\n",
      "开始预测用户1对电影170的评分...\n",
      "预测出用户1对物品170的评分：3.12433\n",
      "开始预测用户1对电影8361的评分...\n",
      "预测出用户1对物品8361的评分：3.00302\n",
      "开始预测用户1对电影172的评分...\n",
      "预测出用户1对物品172的评分：2.29483\n",
      "开始预测用户1对电影173的评分...\n",
      "预测出用户1对物品173的评分：2.25523\n",
      "开始预测用户1对电影8366的评分...\n",
      "预测出用户1对物品8366的评分：3.74039\n",
      "开始预测用户1对电影175的评分...\n",
      "预测出用户1对物品175的评分：3.99024\n",
      "开始预测用户1对电影176的评分...\n",
      "预测出用户1对物品176的评分：4.30522\n",
      "开始预测用户1对电影8368的评分...\n",
      "预测出用户1对物品8368的评分：4.00733\n",
      "开始预测用户1对电影8370的评分...\n",
      "预测出用户1对物品8370的评分：4.07322\n",
      "开始预测用户1对电影8371的评分...\n",
      "预测出用户1对物品8371的评分：2.82050\n",
      "开始预测用户1对电影180的评分...\n",
      "预测出用户1对物品180的评分：3.62204\n",
      "开始预测用户1对电影181的评分...\n",
      "预测出用户1对物品181的评分：1.66595\n",
      "开始预测用户1对电影8373的评分...\n",
      "预测出用户1对物品8373的评分：2.07524\n",
      "开始预测用户1对电影8376的评分...\n",
      "预测出用户1对物品8376的评分：3.53797\n",
      "开始预测用户1对电影185的评分...\n",
      "预测出用户1对物品185的评分：2.69662\n",
      "开始预测用户1对电影186的评分...\n",
      "预测出用户1对物品186的评分：2.43233\n",
      "开始预测用户1对电影188的评分...\n",
      "预测出用户1对物品188的评分：3.60933\n",
      "开始预测用户1对电影193的评分...\n",
      "预测出用户1对物品193的评分：1.98117\n",
      "开始预测用户1对电影194的评分...\n",
      "预测出用户1对物品194的评分：3.54966\n",
      "开始预测用户1对电影196的评分...\n",
      "预测出用户1对物品196的评分：2.33332\n",
      "开始预测用户1对电影198的评分...\n",
      "预测出用户1对物品198的评分：3.28874\n",
      "开始预测用户1对电影106696的评分...\n",
      "预测出用户1对物品106696的评分：3.97079\n",
      "开始预测用户1对电影203的评分...\n",
      "预测出用户1对物品203的评分：3.11287\n",
      "开始预测用户1对电影204的评分...\n",
      "预测出用户1对物品204的评分：2.02024\n",
      "开始预测用户1对电影207的评分...\n",
      "预测出用户1对物品207的评分：2.97483\n",
      "开始预测用户1对电影208的评分...\n",
      "预测出用户1对物品208的评分：2.73543\n",
      "开始预测用户1对电影215的评分...\n",
      "预测出用户1对物品215的评分：4.01823\n",
      "开始预测用户1对电影218的评分...\n",
      "预测出用户1对物品218的评分：3.26216\n",
      "开始预测用户1对电影222的评分...\n",
      "预测出用户1对物品222的评分：3.90588\n",
      "开始预测用户1对电影224的评分...\n",
      "预测出用户1对物品224的评分：3.74763\n",
      "开始预测用户1对电影225的评分...\n",
      "预测出用户1对物品225的评分：3.45212\n",
      "开始预测用户1对电影227的评分...\n",
      "预测出用户1对物品227的评分：2.53087\n",
      "开始预测用户1对电影230的评分...\n",
      "预测出用户1对物品230的评分：3.10355\n",
      "开始预测用户1对电影232的评分...\n",
      "预测出用户1对物品232的评分：3.43603\n",
      "开始预测用户1对电影233的评分...\n",
      "预测出用户1对物品233的评分：3.57779\n",
      "开始预测用户1对电影234的评分...\n",
      "预测出用户1对物品234的评分：2.68738\n",
      "开始预测用户1对电影236的评分...\n",
      "预测出用户1对物品236的评分：3.16407\n",
      "开始预测用户1对电影237的评分...\n",
      "预测出用户1对物品237的评分：2.50696\n",
      "开始预测用户1对电影33004的评分...\n",
      "预测出用户1对物品33004的评分：3.38724\n",
      "开始预测用户1对电影239的评分...\n",
      "预测出用户1对物品239的评分：3.07068\n",
      "开始预测用户1对电影246的评分...\n",
      "预测出用户1对物品246的评分：4.38492\n",
      "开始预测用户1对电影247的评分...\n",
      "预测出用户1对物品247的评分：3.89161\n",
      "开始预测用户1对电影248的评分...\n",
      "预测出用户1对物品248的评分：2.78624\n",
      "开始预测用户1对电影249的评分...\n",
      "预测出用户1对物品249的评分：3.81269\n",
      "开始预测用户1对电影252的评分...\n",
      "预测出用户1对物品252的评分：3.48883\n",
      "开始预测用户1对电影253的评分...\n",
      "预测出用户1对物品253的评分：3.35982\n",
      "开始预测用户1对电影256的评分...\n",
      "预测出用户1对物品256的评分：2.65804\n",
      "开始预测用户1对电影257的评分...\n",
      "预测出用户1对物品257的评分：3.35508\n",
      "开始预测用户1对电影261的评分...\n",
      "预测出用户1对物品261的评分：4.15819\n",
      "开始预测用户1对电影262的评分...\n",
      "预测出用户1对物品262的评分：3.78895\n",
      "开始预测用户1对电影265的评分...\n",
      "预测出用户1对物品265的评分：4.07157\n",
      "开始预测用户1对电影266的评分...\n",
      "预测出用户1对物品266的评分：3.42511\n",
      "开始预测用户1对电影267的评分...\n",
      "预测出用户1对物品267的评分：2.98461\n",
      "开始预测用户1对电影272的评分...\n",
      "预测出用户1对物品272的评分：4.08323\n",
      "开始预测用户1对电影273的评分...\n",
      "预测出用户1对物品273的评分：2.76681\n",
      "开始预测用户1对电影8464的评分...\n",
      "预测出用户1对物品8464的评分：3.52529\n",
      "开始预测用户1对电影276的评分...\n",
      "预测出用户1对物品276的评分：3.13553\n",
      "开始预测用户1对电影277的评分...\n",
      "预测出用户1对物品277的评分：3.41919\n",
      "开始预测用户1对电影280的评分...\n",
      "预测出用户1对物品280的评分：4.54442\n",
      "开始预测用户1对电影281的评分...\n",
      "预测出用户1对物品281的评分：4.32925\n",
      "开始预测用户1对电影282的评分...\n",
      "预测出用户1对物品282的评分：3.39832\n",
      "开始预测用户1对电影106782的评分...\n",
      "预测出用户1对物品106782的评分：3.83536\n",
      "开始预测用户1对电影288的评分...\n",
      "预测出用户1对物品288的评分：3.22725\n",
      "开始预测用户1对电影290的评分...\n",
      "预测出用户1对物品290的评分：4.48585\n",
      "开始预测用户1对电影292的评分...\n",
      "预测出用户1对物品292的评分：3.28771\n",
      "开始预测用户1对电影293的评分...\n",
      "预测出用户1对物品293的评分：4.03188\n",
      "开始预测用户1对电影90405的评分...\n",
      "预测出用户1对物品90405的评分：3.40650\n",
      "开始预测用户1对电影57640的评分...\n",
      "预测出用户1对物品57640的评分：3.81264\n",
      "开始预测用户1对电影300的评分...\n",
      "预测出用户1对物品300的评分：3.42562\n",
      "开始预测用户1对电影303的评分...\n",
      "预测出用户1对物品303的评分：2.92248\n",
      "开始预测用户1对电影306的评分...\n",
      "预测出用户1对物品306的评分：4.19822\n",
      "开始预测用户1对电影307的评分...\n",
      "预测出用户1对物品307的评分：3.46646\n",
      "开始预测用户1对电影308的评分...\n",
      "预测出用户1对物品308的评分：3.94199\n",
      "开始预测用户1对电影314的评分...\n",
      "预测出用户1对物品314的评分：3.53638\n",
      "开始预测用户1对电影315的评分...\n",
      "预测出用户1对物品315的评分：2.90159\n",
      "开始预测用户1对电影317的评分...\n",
      "预测出用户1对物品317的评分：2.96409\n",
      "开始预测用户1对电影318的评分...\n",
      "预测出用户1对物品318的评分：4.55078\n",
      "开始预测用户1对电影319的评分...\n",
      "预测出用户1对物品319的评分：3.95722\n",
      "开始预测用户1对电影41285的评分...\n",
      "预测出用户1对物品41285的评分：3.65598\n",
      "开始预测用户1对电影57669的评分...\n",
      "预测出用户1对物品57669的评分：4.22443\n",
      "开始预测用户1对电影327的评分...\n",
      "预测出用户1对物品327的评分：2.44535\n",
      "开始预测用户1对电影329的评分...\n",
      "预测出用户1对物品329的评分：3.29800\n",
      "开始预测用户1对电影332的评分...\n",
      "预测出用户1对物品332的评分：2.88957\n",
      "开始预测用户1对电影8528的评分...\n",
      "预测出用户1对物品8528的评分：3.39148\n",
      "开始预测用户1对电影337的评分...\n",
      "预测出用户1对物品337的评分：3.73449\n",
      "开始预测用户1对电影338的评分...\n",
      "预测出用户1对物品338的评分：2.35658\n",
      "开始预测用户1对电影339的评分...\n",
      "预测出用户1对物品339的评分：3.37188\n",
      "开始预测用户1对电影8529的评分...\n",
      "预测出用户1对物品8529的评分：3.27438\n",
      "开始预测用户1对电影8533的评分...\n",
      "预测出用户1对物品8533的评分：3.78037\n",
      "开始预测用户1对电影342的评分...\n",
      "预测出用户1对物品342的评分：3.43483\n",
      "开始预测用户1对电影164179的评分...\n",
      "预测出用户1对物品164179的评分：3.84104\n",
      "开始预测用户1对电影344的评分...\n",
      "预测出用户1对物品344的评分：2.99304\n",
      "开始预测用户1对电影345的评分...\n",
      "预测出用户1对物品345的评分：3.61859\n",
      "开始预测用户1对电影348的评分...\n",
      "预测出用户1对物品348的评分：3.64137\n",
      "开始预测用户1对电影350的评分...\n",
      "预测出用户1对物品350的评分：3.07097\n",
      "开始预测用户1对电影351的评分...\n",
      "预测出用户1对物品351的评分：3.21882\n",
      "开始预测用户1对电影353的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品353的评分：3.90380\n",
      "开始预测用户1对电影355的评分...\n",
      "预测出用户1对物品355的评分：1.98519\n",
      "开始预测用户1对电影357的评分...\n",
      "预测出用户1对物品357的评分：3.55351\n",
      "开始预测用户1对电影361的评分...\n",
      "预测出用户1对物品361的评分：2.83158\n",
      "开始预测用户1对电影364的评分...\n",
      "预测出用户1对物品364的评分：3.97517\n",
      "开始预测用户1对电影366的评分...\n",
      "预测出用户1对物品366的评分：2.20172\n",
      "开始预测用户1对电影368的评分...\n",
      "预测出用户1对物品368的评分：3.53399\n",
      "开始预测用户1对电影370的评分...\n",
      "预测出用户1对物品370的评分：3.04002\n",
      "开始预测用户1对电影371的评分...\n",
      "预测出用户1对物品371的评分：3.17015\n",
      "开始预测用户1对电影372的评分...\n",
      "预测出用户1对物品372的评分：2.73537\n",
      "开始预测用户1对电影373的评分...\n",
      "预测出用户1对物品373的评分：3.49781\n",
      "开始预测用户1对电影374的评分...\n",
      "预测出用户1对物品374的评分：1.65998\n",
      "开始预测用户1对电影376的评分...\n",
      "预测出用户1对物品376的评分：3.27789\n",
      "开始预测用户1对电影377的评分...\n",
      "预测出用户1对物品377的评分：3.28610\n",
      "开始预测用户1对电影49530的评分...\n",
      "预测出用户1对物品49530的评分：3.70290\n",
      "开始预测用户1对电影379的评分...\n",
      "预测出用户1对物品379的评分：2.25101\n",
      "开始预测用户1对电影380的评分...\n",
      "预测出用户1对物品380的评分：3.49676\n",
      "开始预测用户1对电影381的评分...\n",
      "预测出用户1对物品381的评分：4.00671\n",
      "开始预测用户1对电影382的评分...\n",
      "预测出用户1对物品382的评分：2.98725\n",
      "开始预测用户1对电影383的评分...\n",
      "预测出用户1对物品383的评分：3.19387\n",
      "开始预测用户1对电影139644的评分...\n",
      "预测出用户1对物品139644的评分：3.81224\n",
      "开始预测用户1对电影33162的评分...\n",
      "预测出用户1对物品33162的评分：3.14721\n",
      "开始预测用户1对电影33166的评分...\n",
      "预测出用户1对物品33166的评分：3.94755\n",
      "开始预测用户1对电影405的评分...\n",
      "预测出用户1对物品405的评分：2.60046\n",
      "开始预测用户1对电影410的评分...\n",
      "预测出用户1对物品410的评分：3.03895\n",
      "开始预测用户1对电影412的评分...\n",
      "预测出用户1对物品412的评分：3.41383\n",
      "开始预测用户1对电影413的评分...\n",
      "预测出用户1对物品413的评分：2.74681\n",
      "开始预测用户1对电影415的评分...\n",
      "预测出用户1对物品415的评分：2.25259\n",
      "开始预测用户1对电影417的评分...\n",
      "预测出用户1对物品417的评分：3.84682\n",
      "开始预测用户1对电影419的评分...\n",
      "预测出用户1对物品419的评分：2.97745\n",
      "开始预测用户1对电影420的评分...\n",
      "预测出用户1对物品420的评分：2.57032\n",
      "开始预测用户1对电影421的评分...\n",
      "预测出用户1对物品421的评分：3.35065\n",
      "开始预测用户1对电影106916的评分...\n",
      "预测出用户1对物品106916的评分：3.72043\n",
      "开始预测用户1对电影106918的评分...\n",
      "预测出用户1对物品106918的评分：4.25911\n",
      "开始预测用户1对电影106920的评分...\n",
      "预测出用户1对物品106920的评分：3.94508\n",
      "开始预测用户1对电影427的评分...\n",
      "预测出用户1对物品427的评分：2.77567\n",
      "开始预测用户1对电影428的评分...\n",
      "预测出用户1对物品428的评分：3.79022\n",
      "开始预测用户1对电影8622的评分...\n",
      "预测出用户1对物品8622的评分：3.63281\n",
      "开始预测用户1对电影431的评分...\n",
      "预测出用户1对物品431的评分：3.62446\n",
      "开始预测用户1对电影432的评分...\n",
      "预测出用户1对物品432的评分：2.31212\n",
      "开始预测用户1对电影8623的评分...\n",
      "预测出用户1对物品8623的评分：3.19297\n",
      "开始预测用户1对电影434的评分...\n",
      "预测出用户1对物品434的评分：2.85310\n",
      "开始预测用户1对电影435的评分...\n",
      "预测出用户1对物品435的评分：2.15691\n",
      "开始预测用户1对电影440的评分...\n",
      "预测出用户1对物品440的评分：3.41479\n",
      "开始预测用户1对电影442的评分...\n",
      "预测出用户1对物品442的评分：2.78448\n",
      "开始预测用户1对电影8636的评分...\n",
      "预测出用户1对物品8636的评分：3.81239\n",
      "开始预测用户1对电影445的评分...\n",
      "预测出用户1对物品445的评分：3.03572\n",
      "开始预测用户1对电影8638的评分...\n",
      "预测出用户1对物品8638的评分：3.29537\n",
      "开始预测用户1对电影8640的评分...\n",
      "预测出用户1对物品8640的评分：2.36348\n",
      "开始预测用户1对电影8641的评分...\n",
      "预测出用户1对物品8641的评分：3.79114\n",
      "开始预测用户1对电影8644的评分...\n",
      "预测出用户1对物品8644的评分：3.35128\n",
      "开始预测用户1对电影454的评分...\n",
      "预测出用户1对物品454的评分：3.47339\n",
      "开始预测用户1对电影455的评分...\n",
      "预测出用户1对物品455的评分：2.40433\n",
      "开始预测用户1对电影115149的评分...\n",
      "预测出用户1对物品115149的评分：3.90627\n",
      "开始预测用户1对电影466的评分...\n",
      "预测出用户1对物品466的评分：2.73647\n",
      "开始预测用户1对电影468的评分...\n",
      "预测出用户1对物品468的评分：3.11714\n",
      "开始预测用户1对电影471的评分...\n",
      "预测出用户1对物品471的评分：3.57628\n",
      "开始预测用户1对电影8665的评分...\n",
      "预测出用户1对物品8665的评分：3.58791\n",
      "开始预测用户1对电影474的评分...\n",
      "预测出用户1对物品474的评分：3.67003\n",
      "开始预测用户1对电影475的评分...\n",
      "预测出用户1对物品475的评分：4.27537\n",
      "开始预测用户1对电影477的评分...\n",
      "预测出用户1对物品477的评分：3.49734\n",
      "开始预测用户1对电影481的评分...\n",
      "预测出用户1对物品481的评分：2.99560\n",
      "开始预测用户1对电影485的评分...\n",
      "预测出用户1对物品485的评分：3.03932\n",
      "开始预测用户1对电影489的评分...\n",
      "预测出用户1对物品489的评分：2.64166\n",
      "开始预测用户1对电影490的评分...\n",
      "预测出用户1对物品490的评分：2.94087\n",
      "开始预测用户1对电影491的评分...\n",
      "预测出用户1对物品491的评分：3.59077\n",
      "开始预测用户1对电影492的评分...\n",
      "预测出用户1对物品492的评分：3.50621\n",
      "开始预测用户1对电影493的评分...\n",
      "预测出用户1对物品493的评分：3.95280\n",
      "开始预测用户1对电影494的评分...\n",
      "预测出用户1对物品494的评分：3.12942\n",
      "开始预测用户1对电影497的评分...\n",
      "预测出用户1对物品497的评分：3.84767\n",
      "开始预测用户1对电影49649的评分...\n",
      "预测出用户1对物品49649的评分：1.76072\n",
      "开始预测用户1对电影49651的评分...\n",
      "预测出用户1对物品49651的评分：3.35041\n",
      "开始预测用户1对电影502的评分...\n",
      "预测出用户1对物品502的评分：2.17630\n",
      "开始预测用户1对电影98809的评分...\n",
      "预测出用户1对物品98809的评分：3.77518\n",
      "开始预测用户1对电影507的评分...\n",
      "预测出用户1对物品507的评分：3.08298\n",
      "开始预测用户1对电影508的评分...\n",
      "预测出用户1对物品508的评分：3.61547\n",
      "开始预测用户1对电影509的评分...\n",
      "预测出用户1对物品509的评分：3.55022\n",
      "开始预测用户1对电影514的评分...\n",
      "预测出用户1对物品514的评分：3.27213\n",
      "开始预测用户1对电影515的评分...\n",
      "预测出用户1对物品515的评分：3.79755\n",
      "开始预测用户1对电影516的评分...\n",
      "预测出用户1对物品516的评分：3.14590\n",
      "开始预测用户1对电影519的评分...\n",
      "预测出用户1对物品519的评分：2.00540\n",
      "开始预测用户1对电影520的评分...\n",
      "预测出用户1对物品520的评分：3.18817\n",
      "开始预测用户1对电影115210的评分...\n",
      "预测出用户1对物品115210的评分：3.74925\n",
      "开始预测用户1对电影524的评分...\n",
      "预测出用户1对物品524的评分：3.46122\n",
      "开始预测用户1对电影529的评分...\n",
      "预测出用户1对物品529的评分：3.80620\n",
      "开始预测用户1对电影531的评分...\n",
      "预测出用户1对物品531的评分：3.41927\n",
      "开始预测用户1对电影532的评分...\n",
      "预测出用户1对物品532的评分：2.97564\n",
      "开始预测用户1对电影533的评分...\n",
      "预测出用户1对物品533的评分：2.68131\n",
      "开始预测用户1对电影534的评分...\n",
      "预测出用户1对物品534的评分：3.93327\n",
      "开始预测用户1对电影535的评分...\n",
      "预测出用户1对物品535的评分：3.03273\n",
      "开始预测用户1对电影537的评分...\n",
      "预测出用户1对物品537的评分：2.97729\n",
      "开始预测用户1对电影538的评分...\n",
      "预测出用户1对物品538的评分：3.83325\n",
      "开始预测用户1对电影539的评分...\n",
      "预测出用户1对物品539的评分：3.38364\n",
      "开始预测用户1对电影82459的评分...\n",
      "预测出用户1对物品82459的评分：3.65597\n",
      "开始预测用户1对电影540的评分...\n",
      "预测出用户1对物品540的评分：2.28803\n",
      "开始预测用户1对电影541的评分...\n",
      "预测出用户1对物品541的评分：4.16658\n",
      "开始预测用户1对电影82461的评分...\n",
      "预测出用户1对物品82461的评分：3.16685\n",
      "开始预测用户1对电影542的评分...\n",
      "预测出用户1对物品542的评分：2.18717\n",
      "开始预测用户1对电影546的评分...\n",
      "预测出用户1对物品546的评分：1.96290\n",
      "开始预测用户1对电影551的评分...\n",
      "预测出用户1对物品551的评分：3.60375\n",
      "开始预测用户1对电影555的评分...\n",
      "预测出用户1对物品555的评分：3.85343\n",
      "开始预测用户1对电影66097的评分...\n",
      "预测出用户1对物品66097的评分：3.67857\n",
      "开始预测用户1对电影562的评分...\n",
      "预测出用户1对物品562的评分：3.54889\n",
      "开始预测用户1对电影575的评分...\n",
      "预测出用户1对物品575的评分：2.61624\n",
      "开始预测用户1对电影585的评分...\n",
      "预测出用户1对物品585的评分：2.63462\n",
      "开始预测用户1对电影586的评分...\n",
      "预测出用户1对物品586的评分：3.03284\n",
      "开始预测用户1对电影587的评分...\n",
      "预测出用户1对物品587的评分：3.36147\n",
      "开始预测用户1对电影588的评分...\n",
      "预测出用户1对物品588的评分：3.76884\n",
      "开始预测用户1对电影589的评分...\n",
      "预测出用户1对物品589的评分：3.97191\n",
      "开始预测用户1对电影8781的评分...\n",
      "预测出用户1对物品8781的评分：2.98332\n",
      "开始预测用户1对电影8783的评分...\n",
      "预测出用户1对物品8783的评分：3.59511\n",
      "开始预测用户1对电影8784的评分...\n",
      "预测出用户1对物品8784的评分：3.89181\n",
      "开始预测用户1对电影594的评分...\n",
      "预测出用户1对物品594的评分：3.81204\n",
      "开始预测用户1对电影595的评分...\n",
      "预测出用户1对物品595的评分：3.67268\n",
      "开始预测用户1对电影597的评分...\n",
      "预测出用户1对物品597的评分：3.49614\n",
      "开始预测用户1对电影599的评分...\n",
      "预测出用户1对物品599的评分：3.99032\n",
      "开始预测用户1对电影8798的评分...\n",
      "预测出用户1对物品8798的评分：3.76707\n",
      "开始预测用户1对电影41566的评分...\n",
      "预测出用户1对物品41566的评分：3.17802\n",
      "开始预测用户1对电影609的评分...\n",
      "预测出用户1对物品609的评分：3.48227\n",
      "开始预测用户1对电影610的评分...\n",
      "预测出用户1对物品610的评分：3.17151\n",
      "开始预测用户1对电影41569的评分...\n",
      "预测出用户1对物品41569的评分：3.47006\n",
      "开始预测用户1对电影41571的评分...\n",
      "预测出用户1对物品41571的评分：3.80796\n",
      "开始预测用户1对电影8807的评分...\n",
      "预测出用户1对物品8807的评分：3.52291\n",
      "开始预测用户1对电影616的评分...\n",
      "预测出用户1对物品616的评分：3.53660\n",
      "开始预测用户1对电影8810的评分...\n",
      "预测出用户1对物品8810的评分：2.64653\n",
      "开始预测用户1对电影628的评分...\n",
      "预测出用户1对物品628的评分：3.43224\n",
      "开始预测用户1对电影631的评分...\n",
      "预测出用户1对物品631的评分：3.14062\n",
      "开始预测用户1对电影90746的评分...\n",
      "预测出用户1对物品90746的评分：3.58326\n",
      "开始预测用户1对电影637的评分...\n",
      "预测出用户1对物品637的评分：2.88166\n",
      "开始预测用户1对电影640的评分...\n",
      "预测出用户1对物品640的评分：2.66136\n",
      "开始预测用户1对电影647的评分...\n",
      "预测出用户1对物品647的评分：3.14585\n",
      "开始预测用户1对电影653的评分...\n",
      "预测出用户1对物品653的评分：2.98082\n",
      "开始预测用户1对电影98961的评分...\n",
      "预测出用户1对物品98961的评分：4.12875\n",
      "开始预测用户1对电影663的评分...\n",
      "预测出用户1对物品663的评分：3.52727\n",
      "开始预测用户1对电影66203的评分...\n",
      "预测出用户1对物品66203的评分：2.82036\n",
      "开始预测用户1对电影8861的评分...\n",
      "预测出用户1对物品8861的评分：2.98422\n",
      "开始预测用户1对电影671的评分...\n",
      "预测出用户1对物品671的评分：3.39585\n",
      "开始预测用户1对电影8865的评分...\n",
      "预测出用户1对物品8865的评分：2.49217\n",
      "开始预测用户1对电影8873的评分...\n",
      "预测出用户1对物品8873的评分：4.01249\n",
      "开始预测用户1对电影8874的评分...\n",
      "预测出用户1对物品8874的评分：4.05739\n",
      "开始预测用户1对电影58025的评分...\n",
      "预测出用户1对物品58025的评分：2.41044\n",
      "开始预测用户1对电影694的评分...\n",
      "预测出用户1对物品694的评分：2.59586\n",
      "开始预测用户1对电影58047的评分...\n",
      "预测出用户1对物品58047的评分：3.66113\n",
      "开始预测用户1对电影99007的评分...\n",
      "预测出用户1对物品99007的评分：3.73059\n",
      "开始预测用户1对电影707的评分...\n",
      "预测出用户1对物品707的评分：2.87122\n",
      "开始预测用户1对电影708的评分...\n",
      "预测出用户1对物品708的评分：3.49068\n",
      "开始预测用户1对电影709的评分...\n",
      "预测出用户1对物品709的评分：3.02576\n",
      "开始预测用户1对电影714的评分...\n",
      "预测出用户1对物品714的评分：4.71691\n",
      "开始预测用户1对电影8907的评分...\n",
      "预测出用户1对物品8907的评分：2.20552\n",
      "开始预测用户1对电影8910的评分...\n",
      "预测出用户1对物品8910的评分：3.57291\n",
      "开始预测用户1对电影719的评分...\n",
      "预测出用户1对物品719的评分：2.76692\n",
      "开始预测用户1对电影720的评分...\n",
      "预测出用户1对物品720的评分：4.43114\n",
      "开始预测用户1对电影8914的评分...\n",
      "预测出用户1对物品8914的评分：3.94864\n",
      "开始预测用户1对电影724的评分...\n",
      "预测出用户1对物品724的评分：2.96496\n",
      "开始预测用户1对电影8917的评分...\n",
      "预测出用户1对物品8917的评分：3.83976\n",
      "开始预测用户1对电影33493的评分...\n",
      "预测出用户1对物品33493的评分：3.45375\n",
      "开始预测用户1对电影74458的评分...\n",
      "预测出用户1对物品74458的评分：4.01824\n",
      "开始预测用户1对电影737的评分...\n",
      "预测出用户1对物品737的评分：2.61471\n",
      "开始预测用户1对电影741的评分...\n",
      "预测出用户1对物品741的评分：4.41417\n",
      "开始预测用户1对电影742的评分...\n",
      "预测出用户1对物品742的评分：2.66720\n",
      "开始预测用户1对电影743的评分...\n",
      "预测出用户1对物品743的评分：2.31643\n",
      "开始预测用户1对电影745的评分...\n",
      "预测出用户1对物品745的评分：3.95206\n",
      "开始预测用户1对电影748的评分...\n",
      "预测出用户1对物品748的评分：2.75090\n",
      "开始预测用户1对电影750的评分...\n",
      "预测出用户1对物品750的评分：4.34218\n",
      "开始预测用户1对电影90866的评分...\n",
      "预测出用户1对物品90866的评分：3.97157\n",
      "开始预测用户1对电影8949的评分...\n",
      "预测出用户1对物品8949的评分：3.76160\n",
      "开始预测用户1对电影8950的评分...\n",
      "预测出用户1对物品8950的评分：4.02937\n",
      "开始预测用户1对电影761的评分...\n",
      "预测出用户1对物品761的评分：3.00518\n",
      "开始预测用户1对电影762的评分...\n",
      "预测出用户1对物品762的评分：2.26317\n",
      "开始预测用户1对电影765的评分...\n",
      "预测出用户1对物品765的评分：3.07597\n",
      "开始预测用户1对电影8957的评分...\n",
      "预测出用户1对物品8957的评分：3.29218\n",
      "开始预测用户1对电影8958的评分...\n",
      "预测出用户1对物品8958的评分：3.83742\n",
      "开始预测用户1对电影8961的评分...\n",
      "预测出用户1对物品8961的评分：3.82843\n",
      "开始预测用户1对电影8965的评分...\n",
      "预测出用户1对物品8965的评分：3.07308\n",
      "开始预测用户1对电影8969的评分...\n",
      "预测出用户1对物品8969的评分：2.91251\n",
      "开始预测用户1对电影778的评分...\n",
      "预测出用户1对物品778的评分：4.14223\n",
      "开始预测用户1对电影8970的评分...\n",
      "预测出用户1对物品8970的评分：3.96836\n",
      "开始预测用户1对电影8972的评分...\n",
      "预测出用户1对物品8972的评分：3.03182\n",
      "开始预测用户1对电影783的评分...\n",
      "预测出用户1对物品783的评分：3.34812\n",
      "开始预测用户1对电影784的评分...\n",
      "预测出用户1对物品784的评分：2.76151\n",
      "开始预测用户1对电影785的评分...\n",
      "预测出用户1对物品785的评分：3.50642\n",
      "开始预测用户1对电影786的评分...\n",
      "预测出用户1对物品786的评分：2.83052\n",
      "开始预测用户1对电影788的评分...\n",
      "预测出用户1对物品788的评分：2.49925\n",
      "开始预测用户1对电影8981的评分...\n",
      "预测出用户1对物品8981的评分：3.49971\n",
      "开始预测用户1对电影8983的评分...\n",
      "预测出用户1对物品8983的评分：3.50569\n",
      "开始预测用户1对电影8984的评分...\n",
      "预测出用户1对物品8984的评分：3.18584\n",
      "开始预测用户1对电影8985的评分...\n",
      "预测出用户1对物品8985的评分：2.01992\n",
      "开始预测用户1对电影798的评分...\n",
      "预测出用户1对物品798的评分：2.20247\n",
      "开始预测用户1对电影799的评分...\n",
      "预测出用户1对物品799的评分：3.29541\n",
      "开始预测用户1对电影800的评分...\n",
      "预测出用户1对物品800的评分：4.45040\n",
      "开始预测用户1对电影801的评分...\n",
      "预测出用户1对物品801的评分：3.10131\n",
      "开始预测用户1对电影802的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品802的评分：3.23510\n",
      "开始预测用户1对电影805的评分...\n",
      "预测出用户1对物品805的评分：3.62436\n",
      "开始预测用户1对电影99112的评分...\n",
      "预测出用户1对物品99112的评分：3.32649\n",
      "开始预测用户1对电影810的评分...\n",
      "预测出用户1对物品810的评分：1.63128\n",
      "开始预测用户1对电影99114的评分...\n",
      "预测出用户1对物品99114的评分：3.91859\n",
      "开始预测用户1对电影830的评分...\n",
      "预测出用户1对物品830的评分：3.10402\n",
      "开始预测用户1对电影832的评分...\n",
      "预测出用户1对物品832的评分：3.21231\n",
      "开始预测用户1对电影836的评分...\n",
      "预测出用户1对物品836的评分：2.46158\n",
      "开始预测用户1对电影837的评分...\n",
      "预测出用户1对物品837的评分：3.26029\n",
      "开始预测用户1对电影838的评分...\n",
      "预测出用户1对物品838的评分：3.93297\n",
      "开始预测用户1对电影839的评分...\n",
      "预测出用户1对物品839的评分：2.56189\n",
      "开始预测用户1对电影842的评分...\n",
      "预测出用户1对物品842的评分：2.21317\n",
      "开始预测用户1对电影140110的评分...\n",
      "预测出用户1对物品140110的评分：3.71513\n",
      "开始预测用户1对电影33615的评分...\n",
      "预测出用户1对物品33615的评分：3.31993\n",
      "开始预测用户1对电影849的评分...\n",
      "预测出用户1对物品849的评分：2.65158\n",
      "开始预测用户1对电影852的评分...\n",
      "预测出用户1对物品852的评分：3.23247\n",
      "开始预测用户1对电影107348的评分...\n",
      "预测出用户1对物品107348的评分：3.89248\n",
      "开始预测用户1对电影858的评分...\n",
      "预测出用户1对物品858的评分：4.39226\n",
      "开始预测用户1对电影866的评分...\n",
      "预测出用户1对物品866的评分：3.83105\n",
      "开始预测用户1对电影880的评分...\n",
      "预测出用户1对物品880的评分：2.32497\n",
      "开始预测用户1对电影115569的评分...\n",
      "预测出用户1对物品115569的评分：4.48629\n",
      "开始预测用户1对电影892的评分...\n",
      "预测出用户1对物品892的评分：3.65954\n",
      "开始预测用户1对电影33660的评分...\n",
      "预测出用户1对物品33660的评分：4.08564\n",
      "开始预测用户1对电影898的评分...\n",
      "预测出用户1对物品898的评分：4.31479\n",
      "开始预测用户1对电影899的评分...\n",
      "预测出用户1对物品899的评分：4.07460\n",
      "开始预测用户1对电影900的评分...\n",
      "预测出用户1对物品900的评分：4.06169\n",
      "开始预测用户1对电影902的评分...\n",
      "预测出用户1对物品902的评分：3.97687\n",
      "开始预测用户1对电影903的评分...\n",
      "预测出用户1对物品903的评分：4.02882\n",
      "开始预测用户1对电影904的评分...\n",
      "预测出用户1对物品904的评分：4.19601\n",
      "开始预测用户1对电影905的评分...\n",
      "预测出用户1对物品905的评分：4.10067\n",
      "开始预测用户1对电影908的评分...\n",
      "预测出用户1对物品908的评分：4.20055\n",
      "开始预测用户1对电影909的评分...\n",
      "预测出用户1对物品909的评分：4.07297\n",
      "开始预测用户1对电影910的评分...\n",
      "预测出用户1对物品910的评分：4.16080\n",
      "开始预测用户1对电影911的评分...\n",
      "预测出用户1对物品911的评分：3.74833\n",
      "开始预测用户1对电影912的评分...\n",
      "预测出用户1对物品912的评分：4.40625\n",
      "开始预测用户1对电影913的评分...\n",
      "预测出用户1对物品913的评分：4.08260\n",
      "开始预测用户1对电影914的评分...\n",
      "预测出用户1对物品914的评分：4.13819\n",
      "开始预测用户1对电影915的评分...\n",
      "预测出用户1对物品915的评分：3.96006\n",
      "开始预测用户1对电影916的评分...\n",
      "预测出用户1对物品916的评分：4.36973\n",
      "开始预测用户1对电影33679的评分...\n",
      "预测出用户1对物品33679的评分：3.30057\n",
      "开始预测用户1对电影50068的评分...\n",
      "预测出用户1对物品50068的评分：3.94550\n",
      "开始预测用户1对电影107406的评分...\n",
      "预测出用户1对物品107406的评分：3.82814\n",
      "开始预测用户1对电影920的评分...\n",
      "预测出用户1对物品920的评分：3.65681\n",
      "开始预测用户1对电影922的评分...\n",
      "预测出用户1对物品922的评分：4.32290\n",
      "开始预测用户1对电影924的评分...\n",
      "预测出用户1对物品924的评分：3.95911\n",
      "开始预测用户1对电影926的评分...\n",
      "预测出用户1对物品926的评分：4.07020\n",
      "开始预测用户1对电影928的评分...\n",
      "预测出用户1对物品928的评分：4.07829\n",
      "开始预测用户1对电影115617的评分...\n",
      "预测出用户1对物品115617的评分：3.83390\n",
      "开始预测用户1对电影930的评分...\n",
      "预测出用户1对物品930的评分：4.17697\n",
      "开始预测用户1对电影933的评分...\n",
      "预测出用户1对物品933的评分：4.35754\n",
      "开始预测用户1对电影934的评分...\n",
      "预测出用户1对物品934的评分：3.46415\n",
      "开始预测用户1对电影58293的评分...\n",
      "预测出用户1对物品58293的评分：2.55462\n",
      "开始预测用户1对电影951的评分...\n",
      "预测出用户1对物品951的评分：4.33866\n",
      "开始预测用户1对电影952的评分...\n",
      "预测出用户1对物品952的评分：3.66010\n",
      "开始预测用户1对电影953的评分...\n",
      "预测出用户1对物品953的评分：3.98529\n",
      "开始预测用户1对电影58295的评分...\n",
      "预测出用户1对物品58295的评分：3.38056\n",
      "开始预测用户1对电影955的评分...\n",
      "预测出用户1对物品955的评分：3.99997\n",
      "开始预测用户1对电影965的评分...\n",
      "预测出用户1对物品965的评分：3.74718\n",
      "开始预测用户1对电影91077的评分...\n",
      "预测出用户1对物品91077的评分：3.74716\n",
      "开始预测用户1对电影968的评分...\n",
      "预测出用户1对物品968的评分：3.46824\n",
      "开始预测用户1对电影969的评分...\n",
      "预测出用户1对物品969的评分：3.95363\n",
      "开始预测用户1对电影986的评分...\n",
      "预测出用户1对物品986的评分：3.21567\n",
      "开始预测用户1对电影991的评分...\n",
      "预测出用户1对物品991的评分：3.23034\n",
      "开始预测用户1对电影994的评分...\n",
      "预测出用户1对物品994的评分：4.09058\n",
      "开始预测用户1对电影996的评分...\n",
      "预测出用户1对物品996的评分：2.46192\n",
      "开始预测用户1对电影999的评分...\n",
      "预测出用户1对物品999的评分：2.91432\n",
      "开始预测用户1对电影1013的评分...\n",
      "预测出用户1对物品1013的评分：3.54470\n",
      "开始预测用户1对电影1015的评分...\n",
      "预测出用户1对物品1015的评分：2.90530\n",
      "开始预测用户1对电影1019的评分...\n",
      "预测出用户1对物品1019的评分：3.83989\n",
      "开始预测用户1对电影1020的评分...\n",
      "预测出用户1对物品1020的评分：3.04181\n",
      "开始预测用户1对电影1021的评分...\n",
      "预测出用户1对物品1021的评分：2.17492\n",
      "开始预测用户1对电影1022的评分...\n",
      "预测出用户1对物品1022的评分：3.82506\n",
      "开始预测用户1对电影115713的评分...\n",
      "预测出用户1对物品115713的评分：3.99409\n",
      "开始预测用户1对电影33794的评分...\n",
      "预测出用户1对物品33794的评分：3.85487\n",
      "开始预测用户1对电影1027的评分...\n",
      "预测出用户1对物品1027的评分：3.00898\n",
      "开始预测用户1对电影1028的评分...\n",
      "预测出用户1对物品1028的评分：3.90545\n",
      "开始预测用户1对电影1033的评分...\n",
      "预测出用户1对物品1033的评分：3.78824\n",
      "开始预测用户1对电影1035的评分...\n",
      "预测出用户1对物品1035的评分：3.87652\n",
      "开始预测用户1对电影1036的评分...\n",
      "预测出用户1对物品1036的评分：3.82318\n",
      "开始预测用户1对电影1037的评分...\n",
      "预测出用户1对物品1037的评分：2.50730\n",
      "开始预测用户1对电影41997的评分...\n",
      "预测出用户1对物品41997的评分：4.15682\n",
      "开始预测用户1对电影1041的评分...\n",
      "预测出用户1对物品1041的评分：4.76237\n",
      "开始预测用户1对电影1047的评分...\n",
      "预测出用户1对物品1047的评分：3.13351\n",
      "开始预测用户1对电影42011的评分...\n",
      "预测出用户1对物品42011的评分：2.36590\n",
      "开始预测用户1对电影1057的评分...\n",
      "预测出用户1对物品1057的评分：3.80700\n",
      "开始预测用户1对电影1059的评分...\n",
      "预测出用户1对物品1059的评分：3.74953\n",
      "开始预测用户1对电影1061的评分...\n",
      "预测出用户1对物品1061的评分：3.63331\n",
      "开始预测用户1对电影74789的评分...\n",
      "预测出用户1对物品74789的评分：3.09837\n",
      "开始预测用户1对电影1064的评分...\n",
      "预测出用户1对物品1064的评分：2.82714\n",
      "开始预测用户1对电影33836的评分...\n",
      "预测出用户1对物品33836的评分：2.26295\n",
      "开始预测用户1对电影1077的评分...\n",
      "预测出用户1对物品1077的评分：3.67364\n",
      "开始预测用户1对电影1078的评分...\n",
      "预测出用户1对物品1078的评分：3.90264\n",
      "开始预测用户1对电影1079的评分...\n",
      "预测出用户1对物品1079的评分：3.95368\n",
      "开始预测用户1对电影1081的评分...\n",
      "预测出用户1对物品1081的评分：3.15382\n",
      "开始预测用户1对电影1084的评分...\n",
      "预测出用户1对物品1084的评分：3.98923\n",
      "开始预测用户1对电影1086的评分...\n",
      "预测出用户1对物品1086的评分：4.13517\n",
      "开始预测用户1对电影1088的评分...\n",
      "预测出用户1对物品1088的评分：3.44387\n",
      "开始预测用户1对电影1091的评分...\n",
      "预测出用户1对物品1091的评分：2.47896\n",
      "开始预测用户1对电影1093的评分...\n",
      "预测出用户1对物品1093的评分：3.32790\n",
      "开始预测用户1对电影1094的评分...\n",
      "预测出用户1对物品1094的评分：3.40853\n",
      "开始预测用户1对电影1095的评分...\n",
      "预测出用户1对物品1095的评分：3.79971\n",
      "开始预测用户1对电影1100的评分...\n",
      "预测出用户1对物品1100的评分：2.39202\n",
      "开始预测用户1对电影1101的评分...\n",
      "预测出用户1对物品1101的评分：3.21338\n",
      "开始预测用户1对电影1103的评分...\n",
      "预测出用户1对物品1103的评分：3.96881\n",
      "开始预测用户1对电影1104的评分...\n",
      "预测出用户1对物品1104的评分：4.54743\n",
      "开始预测用户1对电影1120的评分...\n",
      "预测出用户1对物品1120的评分：3.63378\n",
      "开始预测用户1对电影1124的评分...\n",
      "预测出用户1对物品1124的评分：4.01896\n",
      "开始预测用户1对电影1125的评分...\n",
      "预测出用户1对物品1125的评分：3.82548\n",
      "开始预测用户1对电影1129的评分...\n",
      "预测出用户1对物品1129的评分：3.44430\n",
      "开始预测用户1对电影1131的评分...\n",
      "预测出用户1对物品1131的评分：4.23272\n",
      "开始预测用户1对电影1135的评分...\n",
      "预测出用户1对物品1135的评分：3.11358\n",
      "开始预测用户1对电影1148的评分...\n",
      "预测出用户1对物品1148的评分：4.09609\n",
      "开始预测用户1对电影148626的评分...\n",
      "预测出用户1对物品148626的评分：4.13894\n",
      "开始预测用户1对电影1171的评分...\n",
      "预测出用户1对物品1171的评分：3.62026\n",
      "开始预测用户1对电影1172的评分...\n",
      "预测出用户1对物品1172的评分：4.40751\n",
      "开始预测用户1对电影1173的评分...\n",
      "预测出用户1对物品1173的评分：3.07817\n",
      "开始预测用户1对电影1175的评分...\n",
      "预测出用户1对物品1175的评分：3.86788\n",
      "开始预测用户1对电影1178的评分...\n",
      "预测出用户1对物品1178的评分：4.57488\n",
      "开始预测用户1对电影1179的评分...\n",
      "预测出用户1对物品1179的评分：3.34780\n",
      "开始预测用户1对电影1183的评分...\n",
      "预测出用户1对物品1183的评分：3.89043\n",
      "开始预测用户1对电影1186的评分...\n",
      "预测出用户1对物品1186的评分：3.47523\n",
      "开始预测用户1对电影1188的评分...\n",
      "预测出用户1对物品1188的评分：4.13453\n",
      "开始预测用户1对电影1189的评分...\n",
      "预测出用户1对物品1189的评分：3.57451\n",
      "开始预测用户1对电影1193的评分...\n",
      "预测出用户1对物品1193的评分：4.19754\n",
      "开始预测用户1对电影1194的评分...\n",
      "预测出用户1对物品1194的评分：3.52609\n",
      "开始预测用户1对电影1199的评分...\n",
      "预测出用户1对物品1199的评分：4.29888\n",
      "开始预测用户1对电影1200的评分...\n",
      "预测出用户1对物品1200的评分：3.83588\n",
      "开始预测用户1对电影1201的评分...\n",
      "预测出用户1对物品1201的评分：4.27593\n",
      "开始预测用户1对电影1203的评分...\n",
      "预测出用户1对物品1203的评分：4.17014\n",
      "开始预测用户1对电影1204的评分...\n",
      "预测出用户1对物品1204的评分：4.22774\n",
      "开始预测用户1对电影1207的评分...\n",
      "预测出用户1对物品1207的评分：4.22259\n",
      "开始预测用户1对电影1209的评分...\n",
      "预测出用户1对物品1209的评分：4.40518\n",
      "开始预测用户1对电影1211的评分...\n",
      "预测出用户1对物品1211的评分：3.70679\n",
      "开始预测用户1对电影1212的评分...\n",
      "预测出用户1对物品1212的评分：4.20915\n",
      "开始预测用户1对电影83134的评分...\n",
      "预测出用户1对物品83134的评分：3.78165\n",
      "开始预测用户1对电影1215的评分...\n",
      "预测出用户1对物品1215的评分：3.95741\n",
      "开始预测用户1对电影1216的评分...\n",
      "预测出用户1对物品1216的评分：3.43037\n",
      "开始预测用户1对电影1217的评分...\n",
      "预测出用户1对物品1217的评分：4.56402\n",
      "开始预测用户1对电影1218的评分...\n",
      "预测出用户1对物品1218的评分：3.94397\n",
      "开始预测用户1对电影58559的评分...\n",
      "预测出用户1对物品58559的评分：4.16983\n",
      "开始预测用户1对电影1221的评分...\n",
      "预测出用户1对物品1221的评分：4.33533\n",
      "开始预测用户1对电影1223的评分...\n",
      "预测出用户1对物品1223的评分：4.32336\n",
      "开始预测用户1对电影1225的评分...\n",
      "预测出用户1对物品1225的评分：4.16126\n",
      "开始预测用户1对电影1227的评分...\n",
      "预测出用户1对物品1227的评分：4.40250\n",
      "开始预测用户1对电影1228的评分...\n",
      "预测出用户1对物品1228的评分：4.21544\n",
      "开始预测用户1对电影1230的评分...\n",
      "预测出用户1对物品1230的评分：4.09655\n",
      "开始预测用户1对电影1231的评分...\n",
      "预测出用户1对物品1231的评分：3.95938\n",
      "开始预测用户1对电影1233的评分...\n",
      "预测出用户1对物品1233的评分：4.36227\n",
      "开始预测用户1对电影1234的评分...\n",
      "预测出用户1对物品1234的评分：3.99803\n",
      "开始预测用户1对电影1235的评分...\n",
      "预测出用户1对物品1235的评分：4.63070\n",
      "开始预测用户1对电影1237的评分...\n",
      "预测出用户1对物品1237的评分：4.29731\n",
      "开始预测用户1对电影1242的评分...\n",
      "预测出用户1对物品1242的评分：4.06251\n",
      "开始预测用户1对电影1243的评分...\n",
      "预测出用户1对物品1243的评分：4.48161\n",
      "开始预测用户1对电影1244的评分...\n",
      "预测出用户1对物品1244的评分：4.11343\n",
      "开始预测用户1对电影1245的评分...\n",
      "预测出用户1对物品1245的评分：4.23136\n",
      "开始预测用户1对电影1246的评分...\n",
      "预测出用户1对物品1246的评分：4.15876\n",
      "开始预测用户1对电影1247的评分...\n",
      "预测出用户1对物品1247的评分：4.04824\n",
      "开始预测用户1对电影1248的评分...\n",
      "预测出用户1对物品1248的评分：4.30225\n",
      "开始预测用户1对电影1249的评分...\n",
      "预测出用户1对物品1249的评分：4.01975\n",
      "开始预测用户1对电影1250的评分...\n",
      "预测出用户1对物品1250的评分：4.23867\n",
      "开始预测用户1对电影1251的评分...\n",
      "预测出用户1对物品1251的评分：4.17881\n",
      "开始预测用户1对电影1252的评分...\n",
      "预测出用户1对物品1252的评分：4.28074\n",
      "开始预测用户1对电影1253的评分...\n",
      "预测出用户1对物品1253的评分：3.91460\n",
      "开始预测用户1对电影1254的评分...\n",
      "预测出用户1对物品1254的评分：3.50293\n",
      "开始预测用户1对电影1257的评分...\n",
      "预测出用户1对物品1257的评分：3.74972\n",
      "开始预测用户1对电影1259的评分...\n",
      "预测出用户1对物品1259的评分：4.02333\n",
      "开始预测用户1对电影1260的评分...\n",
      "预测出用户1对物品1260的评分：3.84749\n",
      "开始预测用户1对电影1261的评分...\n",
      "预测出用户1对物品1261的评分：3.93314\n",
      "开始预测用户1对电影1262的评分...\n",
      "预测出用户1对物品1262的评分：4.19178\n",
      "开始预测用户1对电影1263的评分...\n",
      "预测出用户1对物品1263的评分：3.94017\n",
      "开始预测用户1对电影1266的评分...\n",
      "预测出用户1对物品1266的评分：4.15992\n",
      "开始预测用户1对电影1267的评分...\n",
      "预测出用户1对物品1267的评分：4.23558\n",
      "开始预测用户1对电影1269的评分...\n",
      "预测出用户1对物品1269的评分：4.00368\n",
      "开始预测用户1对电影1271的评分...\n",
      "预测出用户1对物品1271的评分：3.31446\n",
      "开始预测用户1对电影1272的评分...\n",
      "预测出用户1对物品1272的评分：3.82665\n",
      "开始预测用户1对电影1273的评分...\n",
      "预测出用户1对物品1273的评分：3.87657\n",
      "开始预测用户1对电影1274的评分...\n",
      "预测出用户1对物品1274的评分：4.06940\n",
      "开始预测用户1对电影1276的评分...\n",
      "预测出用户1对物品1276的评分：4.39538\n",
      "开始预测用户1对电影1277的评分...\n",
      "预测出用户1对物品1277的评分：4.09587\n",
      "开始预测用户1对电影34048的评分...\n",
      "预测出用户1对物品34048的评分：2.96505\n",
      "开始预测用户1对电影1281的评分...\n",
      "预测出用户1对物品1281的评分：4.11994\n",
      "开始预测用户1对电影1283的评分...\n",
      "预测出用户1对物品1283的评分：4.06061\n",
      "开始预测用户1对电影1284的评分...\n",
      "预测出用户1对物品1284的评分：4.07434\n",
      "开始预测用户1对电影1285的评分...\n",
      "预测出用户1对物品1285的评分：3.95628\n",
      "开始预测用户1对电影1287的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品1287的评分：4.24546\n",
      "开始预测用户1对电影1288的评分...\n",
      "预测出用户1对物品1288的评分：4.00957\n",
      "开始预测用户1对电影1289的评分...\n",
      "预测出用户1对物品1289的评分：3.88159\n",
      "开始预测用户1对电影1292的评分...\n",
      "预测出用户1对物品1292的评分：4.16769\n",
      "开始预测用户1对电影1293的评分...\n",
      "预测出用户1对物品1293的评分：3.59553\n",
      "开始预测用户1对电影1295的评分...\n",
      "预测出用户1对物品1295的评分：2.93335\n",
      "开始预测用户1对电影1296的评分...\n",
      "预测出用户1对物品1296的评分：3.77544\n",
      "开始预测用户1对电影1297的评分...\n",
      "预测出用户1对物品1297的评分：3.97185\n",
      "开始预测用户1对电影1299的评分...\n",
      "预测出用户1对物品1299的评分：3.87174\n",
      "开始预测用户1对电影1301的评分...\n",
      "预测出用户1对物品1301的评分：3.39687\n",
      "开始预测用户1对电影1302的评分...\n",
      "预测出用户1对物品1302的评分：3.48164\n",
      "开始预测用户1对电影1303的评分...\n",
      "预测出用户1对物品1303的评分：4.12670\n",
      "开始预测用户1对电影1304的评分...\n",
      "预测出用户1对物品1304的评分：4.10498\n",
      "开始预测用户1对电影34072的评分...\n",
      "预测出用户1对物品34072的评分：3.71305\n",
      "开始预测用户1对电影1307的评分...\n",
      "预测出用户1对物品1307的评分：3.83371\n",
      "开始预测用户1对电影1320的评分...\n",
      "预测出用户1对物品1320的评分：3.25047\n",
      "开始预测用户1对电影1321的评分...\n",
      "预测出用户1对物品1321的评分：3.22774\n",
      "开始预测用户1对电影1327的评分...\n",
      "预测出用户1对物品1327的评分：2.53304\n",
      "开始预测用户1对电影1333的评分...\n",
      "预测出用户1对物品1333的评分：3.50088\n",
      "开始预测用户1对电影1339的评分...\n",
      "预测出用户1对物品1339的评分：3.58985\n",
      "开始预测用户1对电影1342的评分...\n",
      "预测出用户1对物品1342的评分：2.30953\n",
      "开始预测用户1对电影1343的评分...\n",
      "预测出用户1对物品1343的评分：3.70889\n",
      "开始预测用户1对电影1344的评分...\n",
      "预测出用户1对物品1344的评分：3.79639\n",
      "开始预测用户1对电影1345的评分...\n",
      "预测出用户1对物品1345的评分：3.34782\n",
      "开始预测用户1对电影1347的评分...\n",
      "预测出用户1对物品1347的评分：2.97946\n",
      "开始预测用户1对电影1350的评分...\n",
      "预测出用户1对物品1350的评分：3.73487\n",
      "开始预测用户1对电影1356的评分...\n",
      "预测出用户1对物品1356的评分：3.82222\n",
      "开始预测用户1对电影1357的评分...\n",
      "预测出用户1对物品1357的评分：3.82655\n",
      "开始预测用户1对电影1358的评分...\n",
      "预测出用户1对物品1358的评分：4.02382\n",
      "开始预测用户1对电影1359的评分...\n",
      "预测出用户1对物品1359的评分：2.42524\n",
      "开始预测用户1对电影1367的评分...\n",
      "预测出用户1对物品1367的评分：3.08465\n",
      "开始预测用户1对电影1370的评分...\n",
      "预测出用户1对物品1370的评分：3.20962\n",
      "开始预测用户1对电影1371的评分...\n",
      "预测出用户1对物品1371的评分：2.82833\n",
      "开始预测用户1对电影1372的评分...\n",
      "预测出用户1对物品1372的评分：3.32776\n",
      "开始预测用户1对电影1373的评分...\n",
      "预测出用户1对物品1373的评分：2.29310\n",
      "开始预测用户1对电影1374的评分...\n",
      "预测出用户1对物品1374的评分：3.80726\n",
      "开始预测用户1对电影1375的评分...\n",
      "预测出用户1对物品1375的评分：3.15871\n",
      "开始预测用户1对电影1376的评分...\n",
      "预测出用户1对物品1376的评分：3.15998\n",
      "开始预测用户1对电影1378的评分...\n",
      "预测出用户1对物品1378的评分：3.17327\n",
      "开始预测用户1对电影1379的评分...\n",
      "预测出用户1对物品1379的评分：3.11615\n",
      "开始预测用户1对电影1380的评分...\n",
      "预测出用户1对物品1380的评分：3.13391\n",
      "开始预测用户1对电影1381的评分...\n",
      "预测出用户1对物品1381的评分：1.99080\n",
      "开始预测用户1对电影34150的评分...\n",
      "预测出用户1对物品34150的评分：2.83856\n",
      "开始预测用户1对电影1385的评分...\n",
      "预测出用户1对物品1385的评分：2.57621\n",
      "开始预测用户1对电影1387的评分...\n",
      "预测出用户1对物品1387的评分：4.04214\n",
      "开始预测用户1对电影1388的评分...\n",
      "预测出用户1对物品1388的评分：2.48440\n",
      "开始预测用户1对电影91500的评分...\n",
      "预测出用户1对物品91500的评分：3.29271\n",
      "开始预测用户1对电影1391的评分...\n",
      "预测出用户1对物品1391的评分：2.98732\n",
      "开始预测用户1对电影1393的评分...\n",
      "预测出用户1对物品1393的评分：3.50506\n",
      "开始预测用户1对电影1394的评分...\n",
      "预测出用户1对物品1394的评分：3.94485\n",
      "开始预测用户1对电影34162的评分...\n",
      "预测出用户1对物品34162的评分：3.30888\n",
      "开始预测用户1对电影66934的评分...\n",
      "预测出用户1对物品66934的评分：3.69361\n",
      "开始预测用户1对电影1405的评分...\n",
      "预测出用户1对物品1405的评分：2.84099\n",
      "开始预测用户1对电影1407的评分...\n",
      "预测出用户1对物品1407的评分：2.90279\n",
      "开始预测用户1对电影1409的评分...\n",
      "预测出用户1对物品1409的评分：2.42823\n",
      "开始预测用户1对电影1411的评分...\n",
      "预测出用户1对物品1411的评分：3.97834\n",
      "开始预测用户1对电影1416的评分...\n",
      "预测出用户1对物品1416的评分：3.76510\n",
      "开始预测用户1对电影91529的评分...\n",
      "预测出用户1对物品91529的评分：4.06135\n",
      "开始预测用户1对电影91535的评分...\n",
      "预测出用户1对物品91535的评分：3.08605\n",
      "开始预测用户1对电影1429的评分...\n",
      "预测出用户1对物品1429的评分：4.00538\n",
      "开始预测用户1对电影83349的评分...\n",
      "预测出用户1对物品83349的评分：3.03708\n",
      "开始预测用户1对电影1431的评分...\n",
      "预测出用户1对物品1431的评分：2.44494\n",
      "开始预测用户1对电影91542的评分...\n",
      "预测出用户1对物品91542的评分：3.90750\n",
      "开始预测用户1对电影1438的评分...\n",
      "预测出用户1对物品1438的评分：2.15210\n",
      "开始预测用户1对电影1441的评分...\n",
      "预测出用户1对物品1441的评分：2.95070\n",
      "开始预测用户1对电影1449的评分...\n",
      "预测出用户1对物品1449的评分：3.89490\n",
      "开始预测用户1对电影1457的评分...\n",
      "预测出用户1对物品1457的评分：2.78785\n",
      "开始预测用户1对电影1459的评分...\n",
      "预测出用户1对物品1459的评分：2.41147\n",
      "开始预测用户1对电影58803的评分...\n",
      "预测出用户1对物品58803的评分：3.75109\n",
      "开始预测用户1对电影1464的评分...\n",
      "预测出用户1对物品1464的评分：3.15374\n",
      "开始预测用户1对电影1466的评分...\n",
      "预测出用户1对物品1466的评分：3.61558\n",
      "开始预测用户1对电影1474的评分...\n",
      "预测出用户1对物品1474的评分：1.97286\n",
      "开始预测用户1对电影1476的评分...\n",
      "预测出用户1对物品1476的评分：3.64027\n",
      "开始预测用户1对电影1479的评分...\n",
      "预测出用户1对物品1479的评分：2.99149\n",
      "开始预测用户1对电影1480的评分...\n",
      "预测出用户1对物品1480的评分：3.39456\n",
      "开始预测用户1对电影1483的评分...\n",
      "预测出用户1对物品1483的评分：2.41127\n",
      "开始预测用户1对电影1485的评分...\n",
      "预测出用户1对物品1485的评分：2.84037\n",
      "开始预测用户1对电影1488的评分...\n",
      "预测出用户1对物品1488的评分：2.15941\n",
      "开始预测用户1对电影1499的评分...\n",
      "预测出用户1对物品1499的评分：1.64400\n",
      "开始预测用户1对电影1513的评分...\n",
      "预测出用户1对物品1513的评分：2.90913\n",
      "开始预测用户1对电影1515的评分...\n",
      "预测出用户1对物品1515的评分：2.07203\n",
      "开始预测用户1对电影1518的评分...\n",
      "预测出用户1对物品1518的评分：3.05687\n",
      "开始预测用户1对电影91630的评分...\n",
      "预测出用户1对物品91630的评分：3.48782\n",
      "开始预测用户1对电影1527的评分...\n",
      "预测出用户1对物品1527的评分：3.75320\n",
      "开始预测用户1对电影1537的评分...\n",
      "预测出用户1对物品1537的评分：3.65807\n",
      "开始预测用户1对电影1544的评分...\n",
      "预测出用户1对物品1544的评分：2.58341\n",
      "开始预测用户1对电影91658的评分...\n",
      "预测出用户1对物品91658的评分：3.57192\n",
      "开始预测用户1对电影34319的评分...\n",
      "预测出用户1对物品34319的评分：3.19499\n",
      "开始预测用户1对电影67087的评分...\n",
      "预测出用户1对物品67087的评分：3.49420\n",
      "开始预测用户1对电影1556的评分...\n",
      "预测出用户1对物品1556的评分：1.20670\n",
      "开始预测用户1对电影1562的评分...\n",
      "预测出用户1对物品1562的评分：2.06474\n",
      "开始预测用户1对电影1566的评分...\n",
      "预测出用户1对物品1566的评分：3.59910\n",
      "开始预测用户1对电影1569的评分...\n",
      "预测出用户1对物品1569的评分：3.45587\n",
      "开始预测用户1对电影1584的评分...\n",
      "预测出用户1对物品1584的评分：3.42704\n",
      "开始预测用户1对电影1586的评分...\n",
      "预测出用户1对物品1586的评分：2.74701\n",
      "开始预测用户1对电影1588的评分...\n",
      "预测出用户1对物品1588的评分：2.55184\n",
      "开始预测用户1对电影1589的评分...\n",
      "预测出用户1对物品1589的评分：2.86255\n",
      "开始预测用户1对电影1590的评分...\n",
      "预测出用户1对物品1590的评分：2.95290\n",
      "开始预测用户1对电影1591的评分...\n",
      "预测出用户1对物品1591的评分：2.58972\n",
      "开始预测用户1对电影1597的评分...\n",
      "预测出用户1对物品1597的评分：2.85466\n",
      "开始预测用户1对电影1603的评分...\n",
      "预测出用户1对物品1603的评分：2.27120\n",
      "开始预测用户1对电影1608的评分...\n",
      "预测出用户1对物品1608的评分：3.28276\n",
      "开始预测用户1对电影1610的评分...\n",
      "预测出用户1对物品1610的评分：3.86222\n",
      "开始预测用户1对电影1614的评分...\n",
      "预测出用户1对物品1614的评分：2.75207\n",
      "开始预测用户1对电影1615的评分...\n",
      "预测出用户1对物品1615的评分：3.07820\n",
      "开始预测用户1对电影1616的评分...\n",
      "预测出用户1对物品1616的评分：2.77237\n",
      "开始预测用户1对电影1619的评分...\n",
      "预测出用户1对物品1619的评分：3.44099\n",
      "开始预测用户1对电影1635的评分...\n",
      "预测出用户1对物品1635的评分：3.87530\n",
      "开始预测用户1对电影34405的评分...\n",
      "预测出用户1对物品34405的评分：3.88627\n",
      "开始预测用户1对电影1639的评分...\n",
      "预测出用户1对物品1639的评分：3.40689\n",
      "开始预测用户1对电影1641的评分...\n",
      "预测出用户1对物品1641的评分：3.80967\n",
      "开始预测用户1对电影1645的评分...\n",
      "预测出用户1对物品1645的评分：3.39136\n",
      "开始预测用户1对电影157296的评分...\n",
      "预测出用户1对物品157296的评分：3.31326\n",
      "开始预测用户1对电影1653的评分...\n",
      "预测出用户1对物品1653的评分：3.98255\n",
      "开始预测用户1对电影58998的评分...\n",
      "预测出用户1对物品58998的评分：3.91128\n",
      "开始预测用户1对电影1663的评分...\n",
      "预测出用户1对物品1663的评分：3.86263\n",
      "开始预测用户1对电影1665的评分...\n",
      "预测出用户1对物品1665的评分：2.71216\n",
      "开始预测用户1对电影34437的评分...\n",
      "预测出用户1对物品34437的评分：3.41039\n",
      "开始预测用户1对电影1672的评分...\n",
      "预测出用户1对物品1672的评分：3.19981\n",
      "开始预测用户1对电影1673的评分...\n",
      "预测出用户1对物品1673的评分：4.09256\n",
      "开始预测用户1对电影1674的评分...\n",
      "预测出用户1对物品1674的评分：3.66525\n",
      "开始预测用户1对电影59022的评分...\n",
      "预测出用户1对物品59022的评分：3.11817\n",
      "开始预测用户1对电影1680的评分...\n",
      "预测出用户1对物品1680的评分：3.63569\n",
      "开始预测用户1对电影1682的评分...\n",
      "预测出用户1对物品1682的评分：3.86125\n",
      "开始预测用户1对电影1687的评分...\n",
      "预测出用户1对物品1687的评分：2.77781\n",
      "开始预测用户1对电影1688的评分...\n",
      "预测出用户1对物品1688的评分：3.49045\n",
      "开始预测用户1对电影1690的评分...\n",
      "预测出用户1对物品1690的评分：2.78866\n",
      "开始预测用户1对电影1693的评分...\n",
      "预测出用户1对物品1693的评分：3.31802\n",
      "开始预测用户1对电影108190的评分...\n",
      "预测出用户1对物品108190的评分：3.22373\n",
      "开始预测用户1对电影1702的评分...\n",
      "预测出用户1对物品1702的评分：2.84655\n",
      "开始预测用户1对电影1704的评分...\n",
      "预测出用户1对物品1704的评分：4.11382\n",
      "开始预测用户1对电影1711的评分...\n",
      "预测出用户1对物品1711的评分：2.97181\n",
      "开始预测用户1对电影1717的评分...\n",
      "预测出用户1对物品1717的评分：2.73639\n",
      "开始预测用户1对电影1719的评分...\n",
      "预测出用户1对物品1719的评分：4.20374\n",
      "开始预测用户1对电影50872的评分...\n",
      "预测出用户1对物品50872的评分：3.93007\n",
      "开始预测用户1对电影1721的评分...\n",
      "预测出用户1对物品1721的评分：3.37670\n",
      "开始预测用户1对电影1722的评分...\n",
      "预测出用户1对物品1722的评分：2.85177\n",
      "开始预测用户1对电影67255的评分...\n",
      "预测出用户1对物品67255的评分：4.11439\n",
      "开始预测用户1对电影1726的评分...\n",
      "预测出用户1对物品1726的评分：2.41808\n",
      "开始预测用户1对电影1729的评分...\n",
      "预测出用户1对物品1729的评分：3.75183\n",
      "开始预测用户1对电影1735的评分...\n",
      "预测出用户1对物品1735的评分：3.16871\n",
      "开始预测用户1对电影1747的评分...\n",
      "预测出用户1对物品1747的评分：3.15547\n",
      "开始预测用户1对电影1748的评分...\n",
      "预测出用户1对物品1748的评分：3.90482\n",
      "开始预测用户1对电影34520的评分...\n",
      "预测出用户1对物品34520的评分：2.19305\n",
      "开始预测用户1对电影1753的评分...\n",
      "预测出用户1对物品1753的评分：3.68401\n",
      "开始预测用户1对电影1754的评分...\n",
      "预测出用户1对物品1754的评分：3.46835\n",
      "开始预测用户1对电影42723的评分...\n",
      "预测出用户1对物品42723的评分：2.36461\n",
      "开始预测用户1对电影1769的评分...\n",
      "预测出用户1对物品1769的评分：2.69867\n",
      "开始预测用户1对电影1772的评分...\n",
      "预测出用户1对物品1772的评分：2.47988\n",
      "开始预测用户1对电影42738的评分...\n",
      "预测出用户1对物品42738的评分：3.23615\n",
      "开始预测用户1对电影1779的评分...\n",
      "预测出用户1对物品1779的评分：2.61785\n",
      "开始预测用户1对电影1784的评分...\n",
      "预测出用户1对物品1784的评分：3.64897\n",
      "开始预测用户1对电影1792的评分...\n",
      "预测出用户1对物品1792的评分：2.79356\n",
      "开始预测用户1对电影1799的评分...\n",
      "预测出用户1对物品1799的评分：3.48987\n",
      "开始预测用户1对电影1801的评分...\n",
      "预测出用户1对物品1801的评分：3.20439\n",
      "开始预测用户1对电影1810的评分...\n",
      "预测出用户1对物品1810的评分：3.52094\n",
      "开始预测用户1对电影1831的评分...\n",
      "预测出用户1对物品1831的评分：2.14310\n",
      "开始预测用户1对电影1833的评分...\n",
      "预测出用户1对物品1833的评分：2.93169\n",
      "开始预测用户1对电影1834的评分...\n",
      "预测出用户1对物品1834的评分：3.77549\n",
      "开始预测用户1对电影1835的评分...\n",
      "预测出用户1对物品1835的评分：3.34242\n",
      "开始预测用户1对电影1845的评分...\n",
      "预测出用户1对物品1845的评分：3.81326\n",
      "开始预测用户1对电影1848的评分...\n",
      "预测出用户1对物品1848的评分：2.74625\n",
      "开始预测用户1对电影1876的评分...\n",
      "预测出用户1对物品1876的评分：2.78014\n",
      "开始预测用户1对电影1882的评分...\n",
      "预测出用户1对物品1882的评分：1.84199\n",
      "开始预测用户1对电影1883的评分...\n",
      "预测出用户1对物品1883的评分：3.35705\n",
      "开始预测用户1对电影1884的评分...\n",
      "预测出用户1对物品1884的评分：3.93876\n",
      "开始预测用户1对电影1885的评分...\n",
      "预测出用户1对物品1885的评分：2.93741\n",
      "开始预测用户1对电影1892的评分...\n",
      "预测出用户1对物品1892的评分：3.11623\n",
      "开始预测用户1对电影1894的评分...\n",
      "预测出用户1对物品1894的评分：2.66649\n",
      "开始预测用户1对电影1895的评分...\n",
      "预测出用户1对物品1895的评分：2.94422\n",
      "开始预测用户1对电影1907的评分...\n",
      "预测出用户1对物品1907的评分：3.64221\n",
      "开始预测用户1对电影1909的评分...\n",
      "预测出用户1对物品1909的评分：3.42114\n",
      "开始预测用户1对电影1911的评分...\n",
      "预测出用户1对物品1911的评分：2.57187\n",
      "开始预测用户1对电影1912的评分...\n",
      "预测出用户1对物品1912的评分：3.94090\n",
      "开始预测用户1对电影59258的评分...\n",
      "预测出用户1对物品59258的评分：3.71775\n",
      "开始预测用户1对电影1916的评分...\n",
      "预测出用户1对物品1916的评分：3.41829\n",
      "开始预测用户1对电影1917的评分...\n",
      "预测出用户1对物品1917的评分：2.87697\n",
      "开始预测用户1对电影1918的评分...\n",
      "预测出用户1对物品1918的评分：2.91901\n",
      "开始预测用户1对电影1921的评分...\n",
      "预测出用户1对物品1921的评分：3.94793\n",
      "开始预测用户1对电影1923的评分...\n",
      "预测出用户1对物品1923的评分：3.77065\n",
      "开始预测用户1对电影51077的评分...\n",
      "预测出用户1对物品51077的评分：2.36660\n",
      "开始预测用户1对电影51086的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品51086的评分：3.33731\n",
      "开始预测用户1对电影1944的评分...\n",
      "预测出用户1对物品1944的评分：3.81899\n",
      "开始预测用户1对电影1945的评分...\n",
      "预测出用户1对物品1945的评分：4.22095\n",
      "开始预测用户1对电影1947的评分...\n",
      "预测出用户1对物品1947的评分：3.40566\n",
      "开始预测用户1对电影1950的评分...\n",
      "预测出用户1对物品1950的评分：4.20156\n",
      "开始预测用户1对电影1952的评分...\n",
      "预测出用户1对物品1952的评分：3.93819\n",
      "开始预测用户1对电影1953的评分...\n",
      "预测出用户1对物品1953的评分：3.85240\n",
      "开始预测用户1对电影1955的评分...\n",
      "预测出用户1对物品1955的评分：3.98494\n",
      "开始预测用户1对电影1956的评分...\n",
      "预测出用户1对物品1956的评分：4.04046\n",
      "开始预测用户1对电影1957的评分...\n",
      "预测出用户1对物品1957的评分：3.78651\n",
      "开始预测用户1对电影1958的评分...\n",
      "预测出用户1对物品1958的评分：3.73237\n",
      "开始预测用户1对电影1959的评分...\n",
      "预测出用户1对物品1959的评分：3.48049\n",
      "开始预测用户1对电影1960的评分...\n",
      "预测出用户1对物品1960的评分：3.45656\n",
      "开始预测用户1对电影1961的评分...\n",
      "预测出用户1对物品1961的评分：3.96279\n",
      "开始预测用户1对电影1962的评分...\n",
      "预测出用户1对物品1962的评分：3.73851\n",
      "开始预测用户1对电影1963的评分...\n",
      "预测出用户1对物品1963的评分：3.50098\n",
      "开始预测用户1对电影1965的评分...\n",
      "预测出用户1对物品1965的评分：3.49728\n",
      "开始预测用户1对电影1968的评分...\n",
      "预测出用户1对物品1968的评分：3.71406\n",
      "开始预测用户1对电影1970的评分...\n",
      "预测出用户1对物品1970的评分：2.50531\n",
      "开始预测用户1对电影59315的评分...\n",
      "预测出用户1对物品59315的评分：3.89390\n",
      "开始预测用户1对电影1974的评分...\n",
      "预测出用户1对物品1974的评分：2.51642\n",
      "开始预测用户1对电影1982的评分...\n",
      "预测出用户1对物品1982的评分：3.49643\n",
      "开始预测用户1对电影1991的评分...\n",
      "预测出用户1对物品1991的评分：2.54716\n",
      "开始预测用户1对电影1994的评分...\n",
      "预测出用户1对物品1994的评分：3.22311\n",
      "开始预测用户1对电影1997的评分...\n",
      "预测出用户1对物品1997的评分：3.94627\n",
      "开始预测用户1对电影2001的评分...\n",
      "预测出用户1对物品2001的评分：3.19555\n",
      "开始预测用户1对电影2002的评分...\n",
      "预测出用户1对物品2002的评分：2.95608\n",
      "开始预测用户1对电影2003的评分...\n",
      "预测出用户1对物品2003的评分：3.42948\n",
      "开始预测用户1对电影2004的评分...\n",
      "预测出用户1对物品2004的评分：3.19282\n",
      "开始预测用户1对电影2006的评分...\n",
      "预测出用户1对物品2006的评分：2.79055\n",
      "开始预测用户1对电影2009的评分...\n",
      "预测出用户1对物品2009的评分：3.48295\n",
      "开始预测用户1对电影2010的评分...\n",
      "预测出用户1对物品2010的评分：3.65791\n",
      "开始预测用户1对电影2011的评分...\n",
      "预测出用户1对物品2011的评分：3.50411\n",
      "开始预测用户1对电影2013的评分...\n",
      "预测出用户1对物品2013的评分：2.92585\n",
      "开始预测用户1对电影2019的评分...\n",
      "预测出用户1对物品2019的评分：4.34224\n",
      "开始预测用户1对电影2020的评分...\n",
      "预测出用户1对物品2020的评分：3.75772\n",
      "开始预测用户1对电影2021的评分...\n",
      "预测出用户1对物品2021的评分：3.37004\n",
      "开始预测用户1对电影2023的评分...\n",
      "预测出用户1对物品2023的评分：3.51371\n",
      "开始预测用户1对电影174055的评分...\n",
      "预测出用户1对物品174055的评分：3.92971\n",
      "开始预测用户1对电影59369的评分...\n",
      "预测出用户1对物品59369的评分：3.28298\n",
      "开始预测用户1对电影59387的评分...\n",
      "预测出用户1对物品59387的评分：4.31860\n",
      "开始预测用户1对电影2052的评分...\n",
      "预测出用户1对物品2052的评分：2.43589\n",
      "开始预测用户1对电影2053的评分...\n",
      "预测出用户1对物品2053的评分：1.99886\n",
      "开始预测用户1对电影2059的评分...\n",
      "预测出用户1对物品2059的评分：3.00179\n",
      "开始预测用户1对电影2060的评分...\n",
      "预测出用户1对物品2060的评分：3.33432\n",
      "开始预测用户1对电影2064的评分...\n",
      "预测出用户1对物品2064的评分：3.90306\n",
      "开始预测用户1对电影2065的评分...\n",
      "预测出用户1对物品2065的评分：3.92865\n",
      "开始预测用户1对电影2067的评分...\n",
      "预测出用户1对物品2067的评分：4.29461\n",
      "开始预测用户1对电影2072的评分...\n",
      "预测出用户1对物品2072的评分：3.24364\n",
      "开始预测用户1对电影2076的评分...\n",
      "预测出用户1对物品2076的评分：3.98042\n",
      "开始预测用户1对电影2080的评分...\n",
      "预测出用户1对物品2080的评分：3.70612\n",
      "开始预测用户1对电影2081的评分...\n",
      "预测出用户1对物品2081的评分：3.68757\n",
      "开始预测用户1对电影2082的评分...\n",
      "预测出用户1对物品2082的评分：2.60239\n",
      "开始预测用户1对电影2083的评分...\n",
      "预测出用户1对物品2083的评分：3.90257\n",
      "开始预测用户1对电影2085的评分...\n",
      "预测出用户1对物品2085的评分：3.48486\n",
      "开始预测用户1对电影26662的评分...\n",
      "预测出用户1对物品26662的评分：4.07233\n",
      "开始预测用户1对电影2087的评分...\n",
      "预测出用户1对物品2087的评分：3.87395\n",
      "开始预测用户1对电影2088的评分...\n",
      "预测出用户1对物品2088的评分：2.41467\n",
      "开始预测用户1对电影2100的评分...\n",
      "预测出用户1对物品2100的评分：2.93583\n",
      "开始预测用户1对电影51255的评分...\n",
      "预测出用户1对物品51255的评分：3.98225\n",
      "开始预测用户1对电影2108的评分...\n",
      "预测出用户1对物品2108的评分：3.51959\n",
      "开始预测用户1对电影2109的评分...\n",
      "预测出用户1对物品2109的评分：3.49062\n",
      "开始预测用户1对电影2110的评分...\n",
      "预测出用户1对物品2110的评分：3.39745\n",
      "开始预测用户1对电影116797的评分...\n",
      "预测出用户1对物品116797的评分：4.36243\n",
      "开始预测用户1对电影2114的评分...\n",
      "预测出用户1对物品2114的评分：3.85964\n",
      "开始预测用户1对电影2117的评分...\n",
      "预测出用户1对物品2117的评分：3.45439\n",
      "开始预测用户1对电影2118的评分...\n",
      "预测出用户1对物品2118的评分：3.49231\n",
      "开始预测用户1对电影2122的评分...\n",
      "预测出用户1对物品2122的评分：2.39008\n",
      "开始预测用户1对电影2123的评分...\n",
      "预测出用户1对物品2123的评分：2.83441\n",
      "开始预测用户1对电影2124的评分...\n",
      "预测出用户1对物品2124的评分：3.17058\n",
      "开始预测用户1对电影2125的评分...\n",
      "预测出用户1对物品2125的评分：3.38849\n",
      "开始预测用户1对电影2126的评分...\n",
      "预测出用户1对物品2126的评分：2.71707\n",
      "开始预测用户1对电影2133的评分...\n",
      "预测出用户1对物品2133的评分：3.47747\n",
      "开始预测用户1对电影2134的评分...\n",
      "预测出用户1对物品2134的评分：3.21185\n",
      "开始预测用户1对电影2135的评分...\n",
      "预测出用户1对物品2135的评分：4.00253\n",
      "开始预测用户1对电影2136的评分...\n",
      "预测出用户1对物品2136的评分：2.27122\n",
      "开始预测用户1对电影116823的评分...\n",
      "预测出用户1对物品116823的评分：3.84868\n",
      "开始预测用户1对电影2140的评分...\n",
      "预测出用户1对物品2140的评分：3.61776\n",
      "开始预测用户1对电影2144的评分...\n",
      "预测出用户1对物品2144的评分：3.67057\n",
      "开始预测用户1对电影2145的评分...\n",
      "预测出用户1对物品2145的评分：3.28424\n",
      "开始预测用户1对电影2146的评分...\n",
      "预测出用户1对物品2146的评分：3.40428\n",
      "开始预测用户1对电影92259的评分...\n",
      "预测出用户1对物品92259的评分：4.22817\n",
      "开始预测用户1对电影2150的评分...\n",
      "预测出用户1对物品2150的评分：3.94074\n",
      "开始预测用户1对电影2153的评分...\n",
      "预测出用户1对物品2153的评分：2.34351\n",
      "开始预测用户1对电影59501的评分...\n",
      "预测出用户1对物品59501的评分：3.56355\n",
      "开始预测用户1对电影2160的评分...\n",
      "预测出用户1对物品2160的评分：4.18429\n",
      "开始预测用户1对电影2167的评分...\n",
      "预测出用户1对物品2167的评分：3.25485\n",
      "开始预测用户1对电影2186的评分...\n",
      "预测出用户1对物品2186的评分：4.20911\n",
      "开始预测用户1对电影2194的评分...\n",
      "预测出用户1对物品2194的评分：3.94221\n",
      "开始预测用户1对电影67734的评分...\n",
      "预测出用户1对物品67734的评分：3.54745\n",
      "开始预测用户1对电影26776的评分...\n",
      "预测出用户1对物品26776的评分：4.26641\n",
      "开始预测用户1对电影2231的评分...\n",
      "预测出用户1对物品2231的评分：3.84173\n",
      "开始预测用户1对电影2232的评分...\n",
      "预测出用户1对物品2232的评分：3.46480\n",
      "开始预测用户1对电影84152的评分...\n",
      "预测出用户1对物品84152的评分：4.02911\n",
      "开始预测用户1对电影2243的评分...\n",
      "预测出用户1对物品2243的评分：3.74183\n",
      "开始预测用户1对电影2245的评分...\n",
      "预测出用户1对物品2245的评分：3.27479\n",
      "开始预测用户1对电影2247的评分...\n",
      "预测出用户1对物品2247的评分：2.92436\n",
      "开始预测用户1对电影2248的评分...\n",
      "预测出用户1对物品2248的评分：3.92468\n",
      "开始预测用户1对电影2249的评分...\n",
      "预测出用户1对物品2249的评分：2.73983\n",
      "开始预测用户1对电影51412的评分...\n",
      "预测出用户1对物品51412的评分：2.50098\n",
      "开始预测用户1对电影59615的评分...\n",
      "预测出用户1对物品59615的评分：2.69941\n",
      "开始预测用户1对电影2278的评分...\n",
      "预测出用户1对物品2278的评分：3.47241\n",
      "开始预测用户1对电影2288的评分...\n",
      "预测出用户1对物品2288的评分：4.06965\n",
      "开始预测用户1对电影2289的评分...\n",
      "预测出用户1对物品2289的评分：3.97478\n",
      "开始预测用户1对电影2294的评分...\n",
      "预测出用户1对物品2294的评分：3.27587\n",
      "开始预测用户1对电影2297的评分...\n",
      "预测出用户1对物品2297的评分：3.46565\n",
      "开始预测用户1对电影2300的评分...\n",
      "预测出用户1对物品2300的评分：4.14836\n",
      "开始预测用户1对电影2301的评分...\n",
      "预测出用户1对物品2301的评分：3.47806\n",
      "开始预测用户1对电影2302的评分...\n",
      "预测出用户1对物品2302的评分：3.29191\n",
      "开始预测用户1对电影2311的评分...\n",
      "预测出用户1对物品2311的评分：3.56720\n",
      "开始预测用户1对电影2312的评分...\n",
      "预测出用户1对物品2312的评分：3.69656\n",
      "开始预测用户1对电影2313的评分...\n",
      "预测出用户1对物品2313的评分：4.06765\n",
      "开始预测用户1对电影2318的评分...\n",
      "预测出用户1对物品2318的评分：3.95327\n",
      "开始预测用户1对电影2321的评分...\n",
      "预测出用户1对物品2321的评分：3.50109\n",
      "开始预测用户1对电影2324的评分...\n",
      "预测出用户1对物品2324的评分：4.27716\n",
      "开始预测用户1对电影2325的评分...\n",
      "预测出用户1对物品2325的评分：3.48701\n",
      "开始预测用户1对电影2334的评分...\n",
      "预测出用户1对物品2334的评分：2.54253\n",
      "开始预测用户1对电影2335的评分...\n",
      "预测出用户1对物品2335的评分：3.25395\n",
      "开始预测用户1对电影2336的评分...\n",
      "预测出用户1对物品2336的评分：3.90230\n",
      "开始预测用户1对电影2340的评分...\n",
      "预测出用户1对物品2340的评分：2.81462\n",
      "开始预测用户1对电影2346的评分...\n",
      "预测出用户1对物品2346的评分：3.05286\n",
      "开始预测用户1对电影76077的评分...\n",
      "预测出用户1对物品76077的评分：3.23402\n",
      "开始预测用户1对电影2352的评分...\n",
      "预测出用户1对物品2352的评分：3.86738\n",
      "开始预测用户1对电影2355的评分...\n",
      "预测出用户1对物品2355的评分：3.51507\n",
      "开始预测用户1对电影2359的评分...\n",
      "预测出用户1对物品2359的评分：3.78306\n",
      "开始预测用户1对电影2360的评分...\n",
      "预测出用户1对物品2360的评分：4.11330\n",
      "开始预测用户1对电影76093的评分...\n",
      "预测出用户1对物品76093的评分：3.91321\n",
      "开始预测用户1对电影2367的评分...\n",
      "预测出用户1对物品2367的评分：2.76959\n",
      "开始预测用户1对电影2369的评分...\n",
      "预测出用户1对物品2369的评分：2.54962\n",
      "开始预测用户1对电影2371的评分...\n",
      "预测出用户1对物品2371的评分：3.27568\n",
      "开始预测用户1对电影2375的评分...\n",
      "预测出用户1对物品2375的评分：3.00543\n",
      "开始预测用户1对电影2376的评分...\n",
      "预测出用户1对物品2376的评分：3.14159\n",
      "开始预测用户1对电影2378的评分...\n",
      "预测出用户1对物品2378的评分：3.07432\n",
      "开始预测用户1对电影2379的评分...\n",
      "预测出用户1对物品2379的评分：2.34134\n",
      "开始预测用户1对电影59725的评分...\n",
      "预测出用户1对物品59725的评分：2.80171\n",
      "开始预测用户1对电影2384的评分...\n",
      "预测出用户1对物品2384的评分：2.35183\n",
      "开始预测用户1对电影51540的评分...\n",
      "预测出用户1对物品51540的评分：3.81729\n",
      "开始预测用户1对电影2391的评分...\n",
      "预测出用户1对物品2391的评分：3.62607\n",
      "开始预测用户1对电影2393的评分...\n",
      "预测出用户1对物品2393的评分：2.84845\n",
      "开始预测用户1对电影2394的评分...\n",
      "预测出用户1对物品2394的评分：3.28453\n",
      "开始预测用户1对电影2396的评分...\n",
      "预测出用户1对物品2396的评分：3.93623\n",
      "开始预测用户1对电影2398的评分...\n",
      "预测出用户1对物品2398的评分：3.86904\n",
      "开始预测用户1对电影2402的评分...\n",
      "预测出用户1对物品2402的评分：2.37395\n",
      "开始预测用户1对电影2403的评分...\n",
      "预测出用户1对物品2403的评分：3.49153\n",
      "开始预测用户1对电影2404的评分...\n",
      "预测出用户1对物品2404的评分：1.75737\n",
      "开始预测用户1对电影2405的评分...\n",
      "预测出用户1对物品2405的评分：2.90886\n",
      "开始预测用户1对电影2407的评分...\n",
      "预测出用户1对物品2407的评分：3.22108\n",
      "开始预测用户1对电影2409的评分...\n",
      "预测出用户1对物品2409的评分：3.48861\n",
      "开始预测用户1对电影2410的评分...\n",
      "预测出用户1对物品2410的评分：2.91202\n",
      "开始预测用户1对电影2411的评分...\n",
      "预测出用户1对物品2411的评分：2.73614\n",
      "开始预测用户1对电影2412的评分...\n",
      "预测出用户1对物品2412的评分：1.96397\n",
      "开始预测用户1对电影2413的评分...\n",
      "预测出用户1对物品2413的评分：3.39978\n",
      "开始预测用户1对电影2416的评分...\n",
      "预测出用户1对物品2416的评分：2.97844\n",
      "开始预测用户1对电影2420的评分...\n",
      "预测出用户1对物品2420的评分：3.65805\n",
      "开始预测用户1对电影2421的评分...\n",
      "预测出用户1对物品2421的评分：2.83336\n",
      "开始预测用户1对电影2422的评分...\n",
      "预测出用户1对物品2422的评分：1.73154\n",
      "开始预测用户1对电影2423的评分...\n",
      "预测出用户1对物品2423的评分：3.22047\n",
      "开始预测用户1对电影2424的评分...\n",
      "预测出用户1对物品2424的评分：3.17106\n",
      "开始预测用户1对电影2428的评分...\n",
      "预测出用户1对物品2428的评分：2.41715\n",
      "开始预测用户1对电影2431的评分...\n",
      "预测出用户1对物品2431的评分：3.57172\n",
      "开始预测用户1对电影2433的评分...\n",
      "预测出用户1对物品2433的评分：2.97969\n",
      "开始预测用户1对电影108932的评分...\n",
      "预测出用户1对物品108932的评分：4.01679\n",
      "开始预测用户1对电影59784的评分...\n",
      "预测出用户1对物品59784的评分：3.67445\n",
      "开始预测用户1对电影2447的评分...\n",
      "预测出用户1对物品2447的评分：2.93955\n",
      "开始预测用户1对电影76175的评分...\n",
      "预测出用户1对物品76175的评分：2.49892\n",
      "开始预测用户1对电影2454的评分...\n",
      "预测出用户1对物品2454的评分：3.19982\n",
      "开始预测用户1对电影2455的评分...\n",
      "预测出用户1对物品2455的评分：3.36158\n",
      "开始预测用户1对电影84374的评分...\n",
      "预测出用户1对物品84374的评分：3.28970\n",
      "开始预测用户1对电影2463的评分...\n",
      "预测出用户1对物品2463的评分：3.32424\n",
      "开始预测用户1对电影2467的评分...\n",
      "预测出用户1对物品2467的评分：3.79360\n",
      "开始预测用户1对电影2468的评分...\n",
      "预测出用户1对物品2468的评分：2.21216\n",
      "开始预测用户1对电影2471的评分...\n",
      "预测出用户1对物品2471的评分：2.06489\n",
      "开始预测用户1对电影2474的评分...\n",
      "预测出用户1对物品2474的评分：3.63442\n",
      "开始预测用户1对电影2476的评分...\n",
      "预测出用户1对物品2476的评分：3.80497\n",
      "开始预测用户1对电影2485的评分...\n",
      "预测出用户1对物品2485的评分：2.76269\n",
      "开始预测用户1对电影117176的评分...\n",
      "预测出用户1对物品117176的评分：3.82243\n",
      "开始预测用户1对电影2490的评分...\n",
      "预测出用户1对物品2490的评分：3.14133\n",
      "开始预测用户1对电影2496的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品2496的评分：2.58896\n",
      "开始预测用户1对电影2501的评分...\n",
      "预测出用户1对物品2501的评分：3.80182\n",
      "开始预测用户1对电影2505的评分...\n",
      "预测出用户1对物品2505的评分：2.90744\n",
      "开始预测用户1对电影51662的评分...\n",
      "预测出用户1对物品51662的评分：3.70023\n",
      "开始预测用户1对电影76251的评分...\n",
      "预测出用户1对物品76251的评分：3.75720\n",
      "开始预测用户1对电影2527的评分...\n",
      "预测出用户1对物品2527的评分：3.35399\n",
      "开始预测用户1对电影2530的评分...\n",
      "预测出用户1对物品2530的评分：2.68821\n",
      "开始预测用户1对电影2532的评分...\n",
      "预测出用户1对物品2532的评分：2.72909\n",
      "开始预测用户1对电影2533的评分...\n",
      "预测出用户1对物品2533的评分：2.50079\n",
      "开始预测用户1对电影2539的评分...\n",
      "预测出用户1对物品2539的评分：3.19365\n",
      "开始预测用户1对电影2541的评分...\n",
      "预测出用户1对物品2541的评分：2.77916\n",
      "开始预测用户1对电影59900的评分...\n",
      "预测出用户1对物品59900的评分：2.75129\n",
      "开始预测用户1对电影2565的评分...\n",
      "预测出用户1对物品2565的评分：4.05482\n",
      "开始预测用户1对电影76293的评分...\n",
      "预测出用户1对物品76293的评分：3.30036\n",
      "开始预测用户1对电影2567的评分...\n",
      "预测出用户1对物品2567的评分：3.19180\n",
      "开始预测用户1对电影2572的评分...\n",
      "预测出用户1对物品2572的评分：3.19300\n",
      "开始预测用户1对电影2581的评分...\n",
      "预测出用户1对物品2581的评分：2.77120\n",
      "开始预测用户1对电影2583的评分...\n",
      "预测出用户1对物品2583的评分：3.84623\n",
      "开始预测用户1对电影158238的评分...\n",
      "预测出用户1对物品158238的评分：4.06649\n",
      "开始预测用户1对电影2598的评分...\n",
      "预测出用户1对物品2598的评分：2.68251\n",
      "开始预测用户1对电影2599的评分...\n",
      "预测出用户1对物品2599的评分：3.88865\n",
      "开始预测用户1对电影2600的评分...\n",
      "预测出用户1对物品2600的评分：3.86072\n",
      "开始预测用户1对电影2605的评分...\n",
      "预测出用户1对物品2605的评分：2.61310\n",
      "开始预测用户1对电影2606的评分...\n",
      "预测出用户1对物品2606的评分：2.41780\n",
      "开始预测用户1对电影68157的评分...\n",
      "预测出用户1对物品68157的评分：4.12631\n",
      "开始预测用户1对电影2622的评分...\n",
      "预测出用户1对物品2622的评分：3.35758\n",
      "开始预测用户1对电影2642的评分...\n",
      "预测出用户1对物品2642的评分：2.22562\n",
      "开始预测用户1对电影2643的评分...\n",
      "预测出用户1对物品2643的评分：1.61105\n",
      "开始预测用户1对电影2662的评分...\n",
      "预测出用户1对物品2662的评分：3.36226\n",
      "开始预测用户1对电影2664的评分...\n",
      "预测出用户1对物品2664的评分：3.66094\n",
      "开始预测用户1对电影2671的评分...\n",
      "预测出用户1对物品2671的评分：3.38880\n",
      "开始预测用户1对电影2672的评分...\n",
      "预测出用户1对物品2672的评分：3.08640\n",
      "开始预测用户1对电影2683的评分...\n",
      "预测出用户1对物品2683的评分：3.33981\n",
      "开始预测用户1对电影2686的评分...\n",
      "预测出用户1对物品2686的评分：3.88548\n",
      "开始预测用户1对电影2687的评分...\n",
      "预测出用户1对物品2687的评分：3.64487\n",
      "开始预测用户1对电影2688的评分...\n",
      "预测出用户1对物品2688的评分：2.86547\n",
      "开始预测用户1对电影166528的评分...\n",
      "预测出用户1对物品166528的评分：4.06501\n",
      "开始预测用户1对电影2694的评分...\n",
      "预测出用户1对物品2694的评分：3.25151\n",
      "开始预测用户1对电影60040的评分...\n",
      "预测出用户1对物品60040的评分：2.98528\n",
      "开始预测用户1对电影2699的评分...\n",
      "预测出用户1对物品2699的评分：2.64381\n",
      "开始预测用户1对电影2701的评分...\n",
      "预测出用户1对物品2701的评分：2.17892\n",
      "开始预测用户1对电影2702的评分...\n",
      "预测出用户1对物品2702的评分：3.57835\n",
      "开始预测用户1对电影68237的评分...\n",
      "预测出用户1对物品68237的评分：3.50938\n",
      "开始预测用户1对电影2706的评分...\n",
      "预测出用户1对物品2706的评分：3.35711\n",
      "开始预测用户1对电影2707的评分...\n",
      "预测出用户1对物品2707的评分：2.99780\n",
      "开始预测用户1对电影2710的评分...\n",
      "预测出用户1对物品2710的评分：2.62078\n",
      "开始预测用户1对电影2712的评分...\n",
      "预测出用户1对物品2712的评分：3.34731\n",
      "开始预测用户1对电影2713的评分...\n",
      "预测出用户1对物品2713的评分：2.49964\n",
      "开始预测用户1对电影2717的评分...\n",
      "预测出用户1对物品2717的评分：2.90315\n",
      "开始预测用户1对电影2719的评分...\n",
      "预测出用户1对物品2719的评分：2.30005\n",
      "开始预测用户1对电影2720的评分...\n",
      "预测出用户1对物品2720的评分：2.04611\n",
      "开始预测用户1对电影2722的评分...\n",
      "预测出用户1对物品2722的评分：2.53176\n",
      "开始预测用户1对电影2723的评分...\n",
      "预测出用户1对物品2723的评分：3.14525\n",
      "开始预测用户1对电影2724的评分...\n",
      "预测出用户1对物品2724的评分：2.60440\n",
      "开始预测用户1对电影60069的评分...\n",
      "预测出用户1对物品60069的评分：4.06110\n",
      "开始预测用户1对电影2728的评分...\n",
      "预测出用户1对物品2728的评分：3.74533\n",
      "开始预测用户1对电影60072的评分...\n",
      "预测出用户1对物品60072的评分：2.97981\n",
      "开始预测用户1对电影60074的评分...\n",
      "预测出用户1对物品60074的评分：2.97751\n",
      "开始预测用户1对电影2731的评分...\n",
      "预测出用户1对物品2731的评分：3.67993\n",
      "开始预测用户1对电影2735的评分...\n",
      "预测出用户1对物品2735的评分：2.71867\n",
      "开始预测用户1对电影2739的评分...\n",
      "预测出用户1对物品2739的评分：4.08353\n",
      "开始预测用户1对电影2746的评分...\n",
      "预测出用户1对物品2746的评分：3.37832\n",
      "开始预测用户1对电影2762的评分...\n",
      "预测出用户1对物品2762的评分：3.93617\n",
      "开始预测用户1对电影2763的评分...\n",
      "预测出用户1对物品2763的评分：3.47593\n",
      "开始预测用户1对电影2770的评分...\n",
      "预测出用户1对物品2770的评分：3.04567\n",
      "开始预测用户1对电影2779的评分...\n",
      "预测出用户1对物品2779的评分：3.27994\n",
      "开始预测用户1对电影60126的评分...\n",
      "预测出用户1对物品60126的评分：3.19458\n",
      "开始预测用户1对电影51935的评分...\n",
      "预测出用户1对物品51935的评分：3.95061\n",
      "开始预测用户1对电影68319的评分...\n",
      "预测出用户1对物品68319的评分：2.58311\n",
      "开始预测用户1对电影2788的评分...\n",
      "预测出用户1对物品2788的评分：3.97865\n",
      "开始预测用户1对电影2791的评分...\n",
      "预测出用户1对物品2791的评分：3.75979\n",
      "开始预测用户1对电影2792的评分...\n",
      "预测出用户1对物品2792的评分：3.04623\n",
      "开始预测用户1对电影2794的评分...\n",
      "预测出用户1对物品2794的评分：2.63287\n",
      "开始预测用户1对电影2795的评分...\n",
      "预测出用户1对物品2795的评分：3.58630\n",
      "开始预测用户1对电影2796的评分...\n",
      "预测出用户1对物品2796的评分：2.79609\n",
      "开始预测用户1对电影2798的评分...\n",
      "预测出用户1对物品2798的评分：1.39405\n",
      "开始预测用户1对电影2802的评分...\n",
      "预测出用户1对物品2802的评分：3.04667\n",
      "开始预测用户1对电影2803的评分...\n",
      "预测出用户1对物品2803的评分：2.88192\n",
      "开始预测用户1对电影2804的评分...\n",
      "预测出用户1对物品2804的评分：4.09328\n",
      "开始预测用户1对电影2805的评分...\n",
      "预测出用户1对物品2805的评分：2.86147\n",
      "开始预测用户1对电影2808的评分...\n",
      "预测出用户1对物品2808的评分：1.97345\n",
      "开始预测用户1对电影2819的评分...\n",
      "预测出用户1对物品2819的评分：3.94241\n",
      "开始预测用户1对电影2822的评分...\n",
      "预测出用户1对物品2822的评分：2.66164\n",
      "开始预测用户1对电影68358的评分...\n",
      "预测出用户1对物品68358的评分：3.91363\n",
      "开始预测用户1对电影2827的评分...\n",
      "预测出用户1对物品2827的评分：1.99567\n",
      "开始预测用户1对电影2840的评分...\n",
      "预测出用户1对物品2840的评分：2.89749\n",
      "开始预测用户1对电影2841的评分...\n",
      "预测出用户1对物品2841的评分：3.48182\n",
      "开始预测用户1对电影117529的评分...\n",
      "预测出用户1对物品117529的评分：3.45254\n",
      "开始预测用户1对电影84772的评分...\n",
      "预测出用户1对物品84772的评分：3.29076\n",
      "开始预测用户1对电影2857的评分...\n",
      "预测出用户1对物品2857的评分：3.33812\n",
      "开始预测用户1对电影2863的评分...\n",
      "预测出用户1对物品2863的评分：3.59149\n",
      "开始预测用户1对电影2867的评分...\n",
      "预测出用户1对物品2867的评分：3.37655\n",
      "开始预测用户1对电影2871的评分...\n",
      "预测出用户1对物品2871的评分：3.85261\n",
      "开始预测用户1对电影109374的评分...\n",
      "预测出用户1对物品109374的评分：3.66951\n",
      "开始预测用户1对电影2881的评分...\n",
      "预测出用户1对物品2881的评分：2.36780\n",
      "开始预测用户1对电影2890的评分...\n",
      "预测出用户1对物品2890的评分：3.74897\n",
      "开始预测用户1对电影2901的评分...\n",
      "预测出用户1对物品2901的评分：2.46976\n",
      "开始预测用户1对电影117590的评分...\n",
      "预测出用户1对物品117590的评分：3.20946\n",
      "开始预测用户1对电影2908的评分...\n",
      "预测出用户1对物品2908的评分：3.33980\n",
      "开始预测用户1对电影2912的评分...\n",
      "预测出用户1对物品2912的评分：3.85297\n",
      "开始预测用户1对电影2915的评分...\n",
      "预测出用户1对物品2915的评分：3.50869\n",
      "开始预测用户1对电影2918的评分...\n",
      "预测出用户1对物品2918的评分：3.77226\n",
      "开始预测用户1对电影2921的评分...\n",
      "预测出用户1对物品2921的评分：4.33268\n",
      "开始预测用户1对电影2926的评分...\n",
      "预测出用户1对物品2926的评分：3.42649\n",
      "开始预测用户1对电影2942的评分...\n",
      "预测出用户1对物品2942的评分：2.77272\n",
      "开始预测用户1对电影2950的评分...\n",
      "预测出用户1对物品2950的评分：2.50330\n",
      "开始预测用户1对电影2951的评分...\n",
      "预测出用户1对物品2951的评分：4.20416\n",
      "开始预测用户1对电影2952的评分...\n",
      "预测出用户1对物品2952的评分：3.87417\n",
      "开始预测用户1对电影2953的评分...\n",
      "预测出用户1对物品2953的评分：2.22788\n",
      "开始预测用户1对电影2966的评分...\n",
      "预测出用户1对物品2966的评分：4.15195\n",
      "开始预测用户1对电影2968的评分...\n",
      "预测出用户1对物品2968的评分：3.68668\n",
      "开始预测用户1对电影43928的评分...\n",
      "预测出用户1对物品43928的评分：1.79087\n",
      "开始预测用户1对电影2973的评分...\n",
      "预测出用户1对物品2973的评分：3.97409\n",
      "开始预测用户1对电影2986的评分...\n",
      "预测出用户1对物品2986的评分：2.45686\n",
      "开始预测用户1对电影2989的评分...\n",
      "预测出用户1对物品2989的评分：3.58081\n",
      "开始预测用户1对电影2990的评分...\n",
      "预测出用户1对物品2990的评分：3.12868\n",
      "开始预测用户1对电影109487的评分...\n",
      "预测出用户1对物品109487的评分：4.35743\n",
      "开始预测用户1对电影2995的评分...\n",
      "预测出用户1对物品2995的评分：2.41557\n",
      "开始预测用户1对电影3000的评分...\n",
      "预测出用户1对物品3000的评分：4.28614\n",
      "开始预测用户1对电影3004的评分...\n",
      "预测出用户1对物品3004的评分：2.34044\n",
      "开始预测用户1对电影3005的评分...\n",
      "预测出用户1对物品3005的评分：2.38250\n",
      "开始预测用户1对电影3006的评分...\n",
      "预测出用户1对物品3006的评分：3.67397\n",
      "开始预测用户1对电影3016的评分...\n",
      "预测出用户1对物品3016的评分：3.06715\n",
      "开始预测用户1对电影68554的评分...\n",
      "预测出用户1对物品68554的评分：3.44583\n",
      "开始预测用户1对电影3020的评分...\n",
      "预测出用户1对物品3020的评分：3.75930\n",
      "开始预测用户1对电影84944的评分...\n",
      "预测出用户1对物品84944的评分：3.78614\n",
      "开始预测用户1对电影3030的评分...\n",
      "预测出用户1对物品3030的评分：4.63447\n",
      "开始预测用户1对电影84954的评分...\n",
      "预测出用户1对物品84954的评分：3.25135\n",
      "开始预测用户1对电影3035的评分...\n",
      "预测出用户1对物品3035的评分：3.68717\n",
      "开始预测用户1对电影27611的评分...\n",
      "预测出用户1对物品27611的评分：3.98184\n",
      "开始预测用户1对电影3037的评分...\n",
      "预测出用户1对物品3037的评分：4.09352\n",
      "开始预测用户1对电影3039的评分...\n",
      "预测出用户1对物品3039的评分：3.67376\n",
      "开始预测用户1对电影3044的评分...\n",
      "预测出用户1对物品3044的评分：3.55656\n",
      "开始预测用户1对电影60397的评分...\n",
      "预测出用户1对物品60397的评分：2.54395\n",
      "开始预测用户1对电影134130的评分...\n",
      "预测出用户1对物品134130的评分：4.11030\n",
      "开始预测用户1对电影3060的评分...\n",
      "预测出用户1对物品3060的评分：4.03962\n",
      "开始预测用户1对电影44022的评分...\n",
      "预测出用户1对物品44022的评分：3.08236\n",
      "开始预测用户1对电影35836的评分...\n",
      "预测出用户1对物品35836的评分：3.44223\n",
      "开始预测用户1对电影3070的评分...\n",
      "预测出用户1对物品3070的评分：3.72345\n",
      "开始预测用户1对电影3072的评分...\n",
      "预测出用户1对物品3072的评分：3.44787\n",
      "开始预测用户1对电影3081的评分...\n",
      "预测出用户1对物品3081的评分：3.44801\n",
      "开始预测用户1对电影3082的评分...\n",
      "预测出用户1对物品3082的评分：3.14013\n",
      "开始预测用户1对电影3083的评分...\n",
      "预测出用户1对物品3083的评分：4.19020\n",
      "开始预测用户1对电影27660的评分...\n",
      "预测出用户1对物品27660的评分：3.96184\n",
      "开始预测用户1对电影3087的评分...\n",
      "预测出用户1对物品3087的评分：3.34555\n",
      "开始预测用户1对电影3088的评分...\n",
      "预测出用户1对物品3088的评分：3.88424\n",
      "开始预测用户1对电影3089的评分...\n",
      "预测出用户1对物品3089的评分：3.90705\n",
      "开始预测用户1对电影52245的评分...\n",
      "预测出用户1对物品52245的评分：3.16350\n",
      "开始预测用户1对电影3098的评分...\n",
      "预测出用户1对物品3098的评分：3.67308\n",
      "开始预测用户1对电影3100的评分...\n",
      "预测出用户1对物品3100的评分：3.96136\n",
      "开始预测用户1对电影3101的评分...\n",
      "预测出用户1对物品3101的评分：3.12597\n",
      "开始预测用户1对电影3104的评分...\n",
      "预测出用户1对物品3104的评分：3.64431\n",
      "开始预测用户1对电影3105的评分...\n",
      "预测出用户1对物品3105的评分：3.71628\n",
      "开始预测用户1对电影3107的评分...\n",
      "预测出用户1对物品3107的评分：3.02094\n",
      "开始预测用户1对电影3108的评分...\n",
      "预测出用户1对物品3108的评分：3.70566\n",
      "开始预测用户1对电影3113的评分...\n",
      "预测出用户1对物品3113的评分：2.33649\n",
      "开始预测用户1对电影3114的评分...\n",
      "预测出用户1对物品3114的评分：3.71574\n",
      "开始预测用户1对电影52281的评分...\n",
      "预测出用户1对物品52281的评分：3.34466\n",
      "开始预测用户1对电影27706的评分...\n",
      "预测出用户1对物品27706的评分：3.02986\n",
      "开始预测用户1对电影52287的评分...\n",
      "预测出用户1对物品52287的评分：3.69142\n",
      "开始预测用户1对电影3146的评分...\n",
      "预测出用户1对物品3146的评分：2.16819\n",
      "开始预测用户1对电影3148的评分...\n",
      "预测出用户1对物品3148的评分：3.76197\n",
      "开始预测用户1对电影3156的评分...\n",
      "预测出用户1对物品3156的评分：2.64453\n",
      "开始预测用户1对电影3157的评分...\n",
      "预测出用户1对物品3157的评分：2.64894\n",
      "开始预测用户1对电影3159的评分...\n",
      "预测出用户1对物品3159的评分：3.97081\n",
      "开始预测用户1对电影3160的评分...\n",
      "预测出用户1对物品3160的评分：3.75279\n",
      "开始预测用户1对电影3173的评分...\n",
      "预测出用户1对物品3173的评分：2.81356\n",
      "开始预测用户1对电影3174的评分...\n",
      "预测出用户1对物品3174的评分：3.49329\n",
      "开始预测用户1对电影3175的评分...\n",
      "预测出用户1对物品3175的评分：3.52824\n",
      "开始预测用户1对电影52328的评分...\n",
      "预测出用户1对物品52328的评分：3.41294\n",
      "开始预测用户1对电影3178的评分...\n",
      "预测出用户1对物品3178的评分：3.59896\n",
      "开始预测用户1对电影3186的评分...\n",
      "预测出用户1对物品3186的评分：3.29664\n",
      "开始预测用户1对电影3189的评分...\n",
      "预测出用户1对物品3189的评分：3.49639\n",
      "开始预测用户1对电影27773的评分...\n",
      "预测出用户1对物品27773的评分：4.23411\n",
      "开始预测用户1对电影3198的评分...\n",
      "预测出用户1对物品3198的评分：3.93723\n",
      "开始预测用户1对电影3203的评分...\n",
      "预测出用户1对物品3203的评分：2.39001\n",
      "开始预测用户1对电影3210的评分...\n",
      "预测出用户1对物品3210的评分：3.48677\n",
      "开始预测用户1对电影3213的评分...\n",
      "预测出用户1对物品3213的评分：4.02104\n",
      "开始预测用户1对电影93326的评分...\n",
      "预测出用户1对物品93326的评分：2.79275\n",
      "开始预测用户1对电影3219的评分...\n",
      "预测出用户1对物品3219的评分：2.75210\n",
      "开始预测用户1对电影142488的评分...\n",
      "预测出用户1对物品142488的评分：4.46748\n",
      "开始预测用户1对电影27801的评分...\n",
      "预测出用户1对物品27801的评分：3.85296\n",
      "开始预测用户1对电影44191的评分...\n",
      "预测出用户1对物品44191的评分：3.95924\n",
      "开始预测用户1对电影27808的评分...\n",
      "预测出用户1对物品27808的评分：3.74167\n",
      "开始预测用户1对电影44195的评分...\n",
      "预测出用户1对物品44195的评分：4.09854\n",
      "开始预测用户1对电影27815的评分...\n",
      "预测出用户1对物品27815的评分：4.12389\n",
      "开始预测用户1对电影44199的评分...\n",
      "预测出用户1对物品44199的评分：3.63248\n",
      "开始预测用户1对电影3244的评分...\n",
      "预测出用户1对物品3244的评分：3.81903\n",
      "开始预测用户1对电影3246的评分...\n",
      "预测出用户1对物品3246的评分：4.49520\n",
      "开始预测用户1对电影3248的评分...\n",
      "预测出用户1对物品3248的评分：1.76511\n",
      "开始预测用户1对电影93363的评分...\n",
      "预测出用户1对物品93363的评分：2.96680\n",
      "开始预测用户1对电影3252的评分...\n",
      "预测出用户1对物品3252的评分：3.83432\n",
      "开始预测用户1对电影3254的评分...\n",
      "预测出用户1对物品3254的评分：3.28314\n",
      "开始预测用户1对电影27831的评分...\n",
      "预测出用户1对物品27831的评分：4.00142\n",
      "开始预测用户1对电影68791的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品68791的评分：2.98031\n",
      "开始预测用户1对电影3257的评分...\n",
      "预测出用户1对物品3257的评分：2.55799\n",
      "开始预测用户1对电影3258的评分...\n",
      "预测出用户1对物品3258的评分：2.87938\n",
      "开始预测用户1对电影3259的评分...\n",
      "预测出用户1对物品3259的评分：2.97971\n",
      "开始预测用户1对电影3260的评分...\n",
      "预测出用户1对物品3260的评分：3.71081\n",
      "开始预测用户1对电影3261的评分...\n",
      "预测出用户1对物品3261的评分：3.37067\n",
      "开始预测用户1对电影3262的评分...\n",
      "预测出用户1对物品3262的评分：3.23842\n",
      "开始预测用户1对电影3263的评分...\n",
      "预测出用户1对物品3263的评分：3.14864\n",
      "开始预测用户1对电影3264的评分...\n",
      "预测出用户1对物品3264的评分：2.17108\n",
      "开始预测用户1对电影3256的评分...\n",
      "预测出用户1对物品3256的评分：3.51680\n",
      "开始预测用户1对电影3267的评分...\n",
      "预测出用户1对物品3267的评分：3.46292\n",
      "开始预测用户1对电影3268的评分...\n",
      "预测出用户1对物品3268的评分：1.87646\n",
      "开始预测用户1对电影3269的评分...\n",
      "预测出用户1对物品3269的评分：2.81826\n",
      "开始预测用户1对电影3270的评分...\n",
      "预测出用户1对物品3270的评分：2.54617\n",
      "开始预测用户1对电影3271的评分...\n",
      "预测出用户1对物品3271的评分：3.77058\n",
      "开始预测用户1对电影3274的评分...\n",
      "预测出用户1对物品3274的评分：3.68815\n",
      "开始预测用户1对电影3275的评分...\n",
      "预测出用户1对物品3275的评分：4.33357\n",
      "开始预测用户1对电影52435的评分...\n",
      "预测出用户1对物品52435的评分：3.96916\n",
      "开始预测用户1对电影3285的评分...\n",
      "预测出用户1对物品3285的评分：2.94081\n",
      "开始预测用户1对电影106489的评分...\n",
      "预测出用户1对物品106489的评分：3.85901\n",
      "开始预测用户1对电影134368的评分...\n",
      "预测出用户1对物品134368的评分：3.69650\n",
      "开始预测用户1对电影3298的评分...\n",
      "预测出用户1对物品3298的评分：3.73317\n",
      "开始预测用户1对电影3300的评分...\n",
      "预测出用户1对物品3300的评分：3.50399\n",
      "开始预测用户1对电影3301的评分...\n",
      "预测出用户1对物品3301的评分：3.48430\n",
      "开始预测用户1对电影3307的评分...\n",
      "预测出用户1对物品3307的评分：4.26844\n",
      "开始预测用户1对电影3316的评分...\n",
      "预测出用户1对物品3316的评分：2.30725\n",
      "开始预测用户1对电影3317的评分...\n",
      "预测出用户1对物品3317的评分：3.71817\n",
      "开始预测用户1对电影3328的评分...\n",
      "预测出用户1对物品3328的评分：3.72302\n",
      "开始预测用户1对电影27904的评分...\n",
      "预测出用户1对物品27904的评分：3.78917\n",
      "开始预测用户1对电影60684的评分...\n",
      "预测出用户1对物品60684的评分：4.08251\n",
      "开始预测用户1对电影3354的评分...\n",
      "预测出用户1对物品3354的评分：2.65967\n",
      "开始预测用户1对电影3355的评分...\n",
      "预测出用户1对物品3355的评分：3.12429\n",
      "开始预测用户1对电影3359的评分...\n",
      "预测出用户1对物品3359的评分：4.06036\n",
      "开始预测用户1对电影3360的评分...\n",
      "预测出用户1对物品3360的评分：3.62953\n",
      "开始预测用户1对电影3361的评分...\n",
      "预测出用户1对物品3361的评分：3.60812\n",
      "开始预测用户1对电影3362的评分...\n",
      "预测出用户1对物品3362的评分：3.79283\n",
      "开始预测用户1对电影3363的评分...\n",
      "预测出用户1对物品3363的评分：3.73865\n",
      "开始预测用户1对电影3388的评分...\n",
      "预测出用户1对物品3388的评分：2.48531\n",
      "开始预测用户1对电影3396的评分...\n",
      "预测出用户1对物品3396的评分：3.85425\n",
      "开始预测用户1对电影3397的评分...\n",
      "预测出用户1对物品3397的评分：3.61048\n",
      "开始预测用户1对电影3398的评分...\n",
      "预测出用户1对物品3398的评分：3.39110\n",
      "开始预测用户1对电影93510的评分...\n",
      "预测出用户1对物品93510的评分：3.91889\n",
      "开始预测用户1对电影3408的评分...\n",
      "预测出用户1对物品3408的评分：3.42577\n",
      "开始预测用户1对电影3409的评分...\n",
      "预测出用户1对物品3409的评分：2.61315\n",
      "开始预测用户1对电影60756的评分...\n",
      "预测出用户1对物品60756的评分：3.52459\n",
      "开始预测用户1对电影68954的评分...\n",
      "预测出用户1对物品68954的评分：4.07839\n",
      "开始预测用户1对电影3418的评分...\n",
      "预测出用户1对物品3418的评分：3.27448\n",
      "开始预测用户1对电影3421的评分...\n",
      "预测出用户1对物品3421的评分：3.83676\n",
      "开始预测用户1对电影3424的评分...\n",
      "预测出用户1对物品3424的评分：3.75979\n",
      "开始预测用户1对电影3429的评分...\n",
      "预测出用户1对物品3429的评分：4.06909\n",
      "开始预测用户1对电影3435的评分...\n",
      "预测出用户1对物品3435的评分：4.08797\n",
      "开始预测用户1对电影3438的评分...\n",
      "预测出用户1对物品3438的评分：2.99291\n",
      "开始预测用户1对电影159093的评分...\n",
      "预测出用户1对物品159093的评分：4.00497\n",
      "开始预测用户1对电影3451的评分...\n",
      "预测出用户1对物品3451的评分：4.54753\n",
      "开始预测用户1对电影3452的评分...\n",
      "预测出用户1对物品3452的评分：2.95594\n",
      "开始预测用户1对电影52604的评分...\n",
      "预测出用户1对物品52604的评分：4.00457\n",
      "开始预测用户1对电影3461的评分...\n",
      "预测出用户1对物品3461的评分：3.18288\n",
      "开始预测用户1对电影3462的评分...\n",
      "预测出用户1对物品3462的评分：3.93068\n",
      "开始预测用户1对电影3468的评分...\n",
      "预测出用户1对物品3468的评分：4.18749\n",
      "开始预测用户1对电影3471的评分...\n",
      "预测出用户1对物品3471的评分：3.85577\n",
      "开始预测用户1对电影3476的评分...\n",
      "预测出用户1对物品3476的评分：3.65158\n",
      "开始预测用户1对电影3477的评分...\n",
      "预测出用户1对物品3477的评分：3.56658\n",
      "开始预测用户1对电影3481的评分...\n",
      "预测出用户1对物品3481的评分：3.70485\n",
      "开始预测用户1对电影3483的评分...\n",
      "预测出用户1对物品3483的评分：2.74205\n",
      "开始预测用户1对电影85414的评分...\n",
      "预测出用户1对物品85414的评分：3.57141\n",
      "开始预测用户1对电影3499的评分...\n",
      "预测出用户1对物品3499的评分：3.85213\n",
      "开始预测用户1对电影3503的评分...\n",
      "预测出用户1对物品3503的评分：3.87280\n",
      "开始预测用户1对电影3504的评分...\n",
      "预测出用户1对物品3504的评分：3.97380\n",
      "开始预测用户1对电影3507的评分...\n",
      "预测出用户1对物品3507的评分：4.26330\n",
      "开始预测用户1对电影3508的评分...\n",
      "预测出用户1对物品3508的评分：4.28438\n",
      "开始预测用户1对电影3510的评分...\n",
      "预测出用户1对物品3510的评分：3.39737\n",
      "开始预测用户1对电影3526的评分...\n",
      "预测出用户1对物品3526的评分：3.74002\n",
      "开始预测用户1对电影3534的评分...\n",
      "预测出用户1对物品3534的评分：3.24584\n",
      "开始预测用户1对电影3535的评分...\n",
      "预测出用户1对物品3535的评分：3.83677\n",
      "开始预测用户1对电影3536的评分...\n",
      "预测出用户1对物品3536的评分：3.41701\n",
      "开始预测用户1对电影3543的评分...\n",
      "预测出用户1对物品3543的评分：3.89813\n",
      "开始预测用户1对电影3551的评分...\n",
      "预测出用户1对物品3551的评分：3.27629\n",
      "开始预测用户1对电影3552的评分...\n",
      "预测出用户1对物品3552的评分：3.91218\n",
      "开始预测用户1对电影3555的评分...\n",
      "预测出用户1对物品3555的评分：3.41176\n",
      "开始预测用户1对电影3556的评分...\n",
      "预测出用户1对物品3556的评分：3.41537\n",
      "开始预测用户1对电影101864的评分...\n",
      "预测出用户1对物品101864的评分：3.55646\n",
      "开始预测用户1对电影3564的评分...\n",
      "预测出用户1对物品3564的评分：1.39989\n",
      "开始预测用户1对电影52722的评分...\n",
      "预测出用户1对物品52722的评分：3.08460\n",
      "开始预测用户1对电影69122的评分...\n",
      "预测出用户1对物品69122的评分：3.61595\n",
      "开始预测用户1对电影85510的评分...\n",
      "预测出用户1对物品85510的评分：3.09682\n",
      "开始预测用户1对电影3591的评分...\n",
      "预测出用户1对物品3591的评分：2.37746\n",
      "开始预测用户1对电影3593的评分...\n",
      "预测出用户1对物品3593的评分：1.59946\n",
      "开始预测用户1对电影44555的评分...\n",
      "预测出用户1对物品44555的评分：4.02379\n",
      "开始预测用户1对电影60950的评分...\n",
      "预测出用户1对物品60950的评分：3.47556\n",
      "开始预测用户1对电影110102的评分...\n",
      "预测出用户1对物品110102的评分：3.66596\n",
      "开始预测用户1对电影3608的评分...\n",
      "预测出用户1对物品3608的评分：3.05534\n",
      "开始预测用户1对电影3615的评分...\n",
      "预测出用户1对物品3615的评分：2.79635\n",
      "开始预测用户1对电影3618的评分...\n",
      "预测出用户1对物品3618的评分：3.48134\n",
      "开始预测用户1对电影3623的评分...\n",
      "预测出用户1对物品3623的评分：2.49876\n",
      "开始预测用户1对电影3624的评分...\n",
      "预测出用户1对物品3624的评分：3.28836\n",
      "开始预测用户1对电影3633的评分...\n",
      "预测出用户1对物品3633的评分：3.27110\n",
      "开始预测用户1对电影36401的评分...\n",
      "预测出用户1对物品36401的评分：2.51723\n",
      "开始预测用户1对电影3635的评分...\n",
      "预测出用户1对物品3635的评分：3.49705\n",
      "开始预测用户1对电影3638的评分...\n",
      "预测出用户1对物品3638的评分：2.99344\n",
      "开始预测用户1对电影3646的评分...\n",
      "预测出用户1对物品3646的评分：2.37937\n",
      "开始预测用户1对电影3654的评分...\n",
      "预测出用户1对物品3654的评分：3.60046\n",
      "开始预测用户1对电影3668的评分...\n",
      "预测出用户1对物品3668的评分：3.76063\n",
      "开始预测用户1对电影61024的评分...\n",
      "预测出用户1对物品61024的评分：3.89893\n",
      "开始预测用户1对电影3681的评分...\n",
      "预测出用户1对物品3681的评分：4.36519\n",
      "开始预测用户1对电影3683的评分...\n",
      "预测出用户1对物品3683的评分：3.99693\n",
      "开始预测用户1对电影3686的评分...\n",
      "预测出用户1对物品3686的评分：3.11433\n",
      "开始预测用户1对电影3688的评分...\n",
      "预测出用户1对物品3688的评分：2.48636\n",
      "开始预测用户1对电影3697的评分...\n",
      "预测出用户1对物品3697的评分：2.61349\n",
      "开始预测用户1对电影3698的评分...\n",
      "预测出用户1对物品3698的评分：3.01852\n",
      "开始预测用户1对电影3699的评分...\n",
      "预测出用户1对物品3699的评分：3.11481\n",
      "开始预测用户1对电影3701的评分...\n",
      "预测出用户1对物品3701的评分：2.91362\n",
      "开始预测用户1对电影3704的评分...\n",
      "预测出用户1对物品3704的评分：3.23174\n",
      "开始预测用户1对电影44665的评分...\n",
      "预测出用户1对物品44665的评分：3.80573\n",
      "开始预测用户1对电影3717的评分...\n",
      "预测出用户1对物品3717的评分：3.10070\n",
      "开始预测用户1对电影77455的评分...\n",
      "预测出用户1对物品77455的评分：4.19646\n",
      "开始预测用户1对电影93840的评分...\n",
      "预测出用户1对物品93840的评分：4.31652\n",
      "开始预测用户1对电影3730的评分...\n",
      "预测出用户1对物品3730的评分：4.31941\n",
      "开始预测用户1对电影3735的评分...\n",
      "预测出用户1对物品3735的评分：3.58690\n",
      "开始预测用户1对电影3741的评分...\n",
      "预测出用户1对物品3741的评分：4.04646\n",
      "开始预测用户1对电影3745的评分...\n",
      "预测出用户1对物品3745的评分：3.44878\n",
      "开始预测用户1对电影36517的评分...\n",
      "预测出用户1对物品36517的评分：3.55048\n",
      "开始预测用户1对电影3751的评分...\n",
      "预测出用户1对物品3751的评分：3.53071\n",
      "开始预测用户1对电影3752的评分...\n",
      "预测出用户1对物品3752的评分：3.01658\n",
      "开始预测用户1对电影3753的评分...\n",
      "预测出用户1对物品3753的评分：3.26673\n",
      "开始预测用户1对电影36519的评分...\n",
      "预测出用户1对物品36519的评分：3.18674\n",
      "开始预测用户1对电影3755的评分...\n",
      "预测出用户1对物品3755的评分：3.06975\n",
      "开始预测用户1对电影36529的评分...\n",
      "预测出用户1对物品36529的评分：3.59161\n",
      "开始预测用户1对电影3763的评分...\n",
      "预测出用户1对物品3763的评分：3.25348\n",
      "开始预测用户1对电影134853的评分...\n",
      "预测出用户1对物品134853的评分：4.04354\n",
      "开始预测用户1对电影3783的评分...\n",
      "预测出用户1对物品3783的评分：4.08359\n",
      "开始预测用户1对电影3784的评分...\n",
      "预测出用户1对物品3784的评分：2.17863\n",
      "开始预测用户1对电影3785的评分...\n",
      "预测出用户1对物品3785的评分：2.72737\n",
      "开始预测用户1对电影61132的评分...\n",
      "预测出用户1对物品61132的评分：3.35557\n",
      "开始预测用户1对电影3791的评分...\n",
      "预测出用户1对物品3791的评分：2.92401\n",
      "开始预测用户1对电影3798的评分...\n",
      "预测出用户1对物品3798的评分：3.29459\n",
      "开始预测用户1对电影44761的评分...\n",
      "预测出用户1对物品44761的评分：4.00270\n",
      "开始预测用户1对电影3812的评分...\n",
      "预测出用户1对物品3812的评分：3.31872\n",
      "开始预测用户1对电影102123的评分...\n",
      "预测出用户1对物品102123的评分：3.38478\n",
      "开始预测用户1对电影3821的评分...\n",
      "预测出用户1对物品3821的评分：2.22331\n",
      "开始预测用户1对电影52973的评分...\n",
      "预测出用户1对物品52973的评分：3.73481\n",
      "开始预测用户1对电影52975的评分...\n",
      "预测出用户1对物品52975的评分：3.29268\n",
      "开始预测用户1对电影3824的评分...\n",
      "预测出用户1对物品3824的评分：2.39956\n",
      "开始预测用户1对电影3825的评分...\n",
      "预测出用户1对物品3825的评分：2.42023\n",
      "开始预测用户1对电影3826的评分...\n",
      "预测出用户1对物品3826的评分：1.82422\n",
      "开始预测用户1对电影3827的评分...\n",
      "预测出用户1对物品3827的评分：2.98710\n",
      "开始预测用户1对电影102125的评分...\n",
      "预测出用户1对物品102125的评分：3.58392\n",
      "开始预测用户1对电影3831的评分...\n",
      "预测出用户1对物品3831的评分：3.86622\n",
      "开始预测用户1对电影77561的评分...\n",
      "预测出用户1对物品77561的评分：3.50296\n",
      "开始预测用户1对电影3836的评分...\n",
      "预测出用户1对物品3836的评分：4.22832\n",
      "开始预测用户1对电影53000的评分...\n",
      "预测出用户1对物品53000的评分：2.87177\n",
      "开始预测用户1对电影3852的评分...\n",
      "预测出用户1对物品3852的评分：3.55663\n",
      "开始预测用户1对电影3861的评分...\n",
      "预测出用户1对物品3861的评分：2.75669\n",
      "开始预测用户1对电影3863的评分...\n",
      "预测出用户1对物品3863的评分：2.96487\n",
      "开始预测用户1对电影3868的评分...\n",
      "预测出用户1对物品3868的评分：3.37306\n",
      "开始预测用户1对电影3869的评分...\n",
      "预测出用户1对物品3869的评分：3.37240\n",
      "开始预测用户1对电影69406的评分...\n",
      "预测出用户1对物品69406的评分：2.86292\n",
      "开始预测用户1对电影44840的评分...\n",
      "预测出用户1对物品44840的评分：2.81491\n",
      "开始预测用户1对电影3882的评分...\n",
      "预测出用户1对物品3882的评分：2.64726\n",
      "开始预测用户1对电影3893的评分...\n",
      "预测出用户1对物品3893的评分：3.27759\n",
      "开始预测用户1对电影61240的评分...\n",
      "预测出用户1对物品61240的评分：3.74603\n",
      "开始预测用户1对电影3897的评分...\n",
      "预测出用户1对物品3897的评分：3.81127\n",
      "开始预测用户1对电影122892的评分...\n",
      "预测出用户1对物品122892的评分：3.60292\n",
      "开始预测用户1对电影3910的评分...\n",
      "预测出用户1对物品3910的评分：4.01349\n",
      "开始预测用户1对电影3911的评分...\n",
      "预测出用户1对物品3911的评分：3.67027\n",
      "开始预测用户1对电影3916的评分...\n",
      "预测出用户1对物品3916的评分：3.50421\n",
      "开始预测用户1对电影3917的评分...\n",
      "预测出用户1对物品3917的评分：2.95404\n",
      "开始预测用户1对电影36708的评分...\n",
      "预测出用户1对物品36708的评分：3.72040\n",
      "开始预测用户1对电影122900的评分...\n",
      "预测出用户1对物品122900的评分：3.98248\n",
      "开始预测用户1对电影69481的评分...\n",
      "预测出用户1对物品69481的评分：3.86227\n",
      "开始预测用户1对电影3948的评分...\n",
      "预测出用户1对物品3948的评分：3.40195\n",
      "开始预测用户1对电影3949的评分...\n",
      "预测出用户1对物品3949的评分：3.93903\n",
      "开始预测用户1对电影3967的评分...\n",
      "预测出用户1对物品3967的评分：3.92201\n",
      "开始预测用户1对电影3968的评分...\n",
      "预测出用户1对物品3968的评分：3.06725\n",
      "开始预测用户1对电影3969的评分...\n",
      "预测出用户1对物品3969的评分：3.09758\n",
      "开始预测用户1对电影53121的评分...\n",
      "预测出用户1对物品53121的评分：2.37070\n",
      "开始预测用户1对电影3972的评分...\n",
      "预测出用户1对物品3972的评分：4.14482\n",
      "开始预测用户1对电影53125的评分...\n",
      "预测出用户1对物品53125的评分：3.43271\n",
      "开始预测用户1对电影3977的评分...\n",
      "预测出用户1对物品3977的评分：2.73755\n",
      "开始预测用户1对电影3978的评分...\n",
      "预测出用户1对物品3978的评分：2.89563\n",
      "开始预测用户1对电影3979的评分...\n",
      "预测出用户1对物品3979的评分：2.60660\n",
      "开始预测用户1对电影3980的评分...\n",
      "预测出用户1对物品3980的评分：3.09780\n",
      "开始预测用户1对电影3981的评分...\n",
      "预测出用户1对物品3981的评分：2.56013\n",
      "开始预测用户1对电影61323的评分...\n",
      "预测出用户1对物品61323的评分：3.54875\n",
      "开始预测用户1对电影3984的评分...\n",
      "预测出用户1对物品3984的评分：3.42962\n",
      "开始预测用户1对电影3986的评分...\n",
      "预测出用户1对物品3986的评分：2.64342\n",
      "开始预测用户1对电影3988的评分...\n",
      "预测出用户1对物品3988的评分：2.99226\n",
      "开始预测用户1对电影69526的评分...\n",
      "预测出用户1对物品69526的评分：2.10780\n",
      "开始预测用户1对电影3994的评分...\n",
      "预测出用户1对物品3994的评分：3.52110\n",
      "开始预测用户1对电影3996的评分...\n",
      "预测出用户1对物品3996的评分：3.91285\n",
      "开始预测用户1对电影3997的评分...\n",
      "预测出用户1对物品3997的评分：1.57223\n",
      "开始预测用户1对电影3998的评分...\n",
      "预测出用户1对物品3998的评分：2.78138\n",
      "开始预测用户1对电影3999的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品3999的评分：2.45545\n",
      "开始预测用户1对电影4002的评分...\n",
      "预测出用户1对物品4002的评分：3.99438\n",
      "开始预测用户1对电影4005的评分...\n",
      "预测出用户1对物品4005的评分：3.13743\n",
      "开始预测用户1对电影4007的评分...\n",
      "预测出用户1对物品4007的评分：3.59844\n",
      "开始预测用户1对电影4008的评分...\n",
      "预测出用户1对物品4008的评分：3.56468\n",
      "开始预测用户1对电影118696的评分...\n",
      "预测出用户1对物品118696的评分：4.08939\n",
      "开始预测用户1对电影4011的评分...\n",
      "预测出用户1对物品4011的评分：4.21384\n",
      "开始预测用户1对电影44972的评分...\n",
      "预测出用户1对物品44972的评分：2.33967\n",
      "开始预测用户1对电影4014的评分...\n",
      "预测出用户1对物品4014的评分：3.63714\n",
      "开始预测用户1对电影4015的评分...\n",
      "预测出用户1对物品4015的评分：2.62197\n",
      "开始预测用户1对电影4016的评分...\n",
      "预测出用户1对物品4016的评分：3.95713\n",
      "开始预测用户1对电影4017的评分...\n",
      "预测出用户1对物品4017的评分：3.57605\n",
      "开始预测用户1对电影4018的评分...\n",
      "预测出用户1对物品4018的评分：3.00600\n",
      "开始预测用户1对电影4019的评分...\n",
      "预测出用户1对物品4019的评分：3.61504\n",
      "开始预测用户1对电影4020的评分...\n",
      "预测出用户1对物品4020的评分：2.84063\n",
      "开始预测用户1对电影44974的评分...\n",
      "预测出用户1对物品44974的评分：3.07619\n",
      "开始预测用户1对电影4022的评分...\n",
      "预测出用户1对物品4022的评分：3.52198\n",
      "开始预测用户1对电影4023的评分...\n",
      "预测出用户1对物品4023的评分：3.18098\n",
      "开始预测用户1对电影4025的评分...\n",
      "预测出用户1对物品4025的评分：2.79819\n",
      "开始预测用户1对电影4027的评分...\n",
      "预测出用户1对物品4027的评分：3.85184\n",
      "开始预测用户1对电影4029的评分...\n",
      "预测出用户1对物品4029的评分：3.93948\n",
      "开始预测用户1对电影4033的评分...\n",
      "预测出用户1对物品4033的评分：3.98870\n",
      "开始预测用户1对电影4034的评分...\n",
      "预测出用户1对物品4034的评分：3.90279\n",
      "开始预测用户1对电影4036的评分...\n",
      "预测出用户1对物品4036的评分：2.68476\n",
      "开始预测用户1对电影4039的评分...\n",
      "预测出用户1对物品4039的评分：3.38269\n",
      "开始预测用户1对电影4040的评分...\n",
      "预测出用户1对物品4040的评分：2.35920\n",
      "开始预测用户1对电影4041的评分...\n",
      "预测出用户1对物品4041的评分：3.68938\n",
      "开始预测用户1对电影4054的评分...\n",
      "预测出用户1对物品4054的评分：2.98605\n",
      "开始预测用户1对电影110553的评分...\n",
      "预测出用户1对物品110553的评分：2.73533\n",
      "开始预测用户1对电影4069的评分...\n",
      "预测出用户1对物品4069的评分：2.91254\n",
      "开始预测用户1对电影135143的评分...\n",
      "预测出用户1对物品135143的评分：4.03736\n",
      "开始预测用户1对电影4084的评分...\n",
      "预测出用户1对物品4084的评分：2.80890\n",
      "开始预测用户1对电影4085的评分...\n",
      "预测出用户1对物品4085的评分：3.38231\n",
      "开始预测用户1对电影143355的评分...\n",
      "预测出用户1对物品143355的评分：3.90719\n",
      "开始预测用户1对电影102407的评分...\n",
      "预测出用户1对物品102407的评分：3.71104\n",
      "开始预测用户1对电影4105的评分...\n",
      "预测出用户1对物品4105的评分：3.70396\n",
      "开始预测用户1对电影69644的评分...\n",
      "预测出用户1对物品69644的评分：3.38844\n",
      "开始预测用户1对电影4121的评分...\n",
      "预测出用户1对物品4121的评分：3.23625\n",
      "开始预测用户1对电影45081的评分...\n",
      "预测出用户1对物品45081的评分：2.62915\n",
      "开始预测用户1对电影4128的评分...\n",
      "预测出用户1对物品4128的评分：3.68332\n",
      "开始预测用户1对电影102445的评分...\n",
      "预测出用户1对物品102445的评分：3.37773\n",
      "开始预测用户1对电影4144的评分...\n",
      "预测出用户1对物品4144的评分：4.30344\n",
      "开始预测用户1对电影4148的评分...\n",
      "预测出用户1对物品4148的评分：2.99066\n",
      "开始预测用户1对电影4149的评分...\n",
      "预测出用户1对物品4149的评分：2.72670\n",
      "开始预测用户1对电影4153的评分...\n",
      "预测出用户1对物品4153的评分：2.20552\n",
      "开始预测用户1对电影4161的评分...\n",
      "预测出用户1对物品4161的评分：3.09780\n",
      "开始预测用户1对电影53322的评分...\n",
      "预测出用户1对物品53322的评分：3.62394\n",
      "开始预测用户1对电影4214的评分...\n",
      "预测出用户1对物品4214的评分：3.00116\n",
      "开始预测用户1对电影69757的评分...\n",
      "预测出用户1对物品69757的评分：3.82946\n",
      "开始预测用户1对电影4223的评分...\n",
      "预测出用户1对物品4223的评分：3.68324\n",
      "开始预测用户1对电影4226的评分...\n",
      "预测出用户1对物品4226的评分：4.10478\n",
      "开始预测用户1对电影45186的评分...\n",
      "预测出用户1对物品45186的评分：3.45456\n",
      "开始预测用户1对电影4232的评分...\n",
      "预测出用户1对物品4232的评分：2.65192\n",
      "开始预测用户1对电影4235的评分...\n",
      "预测出用户1对物品4235的评分：3.95999\n",
      "开始预测用户1对电影4238的评分...\n",
      "预测出用户1对物品4238的评分：2.86646\n",
      "开始预测用户1对电影4239的评分...\n",
      "预测出用户1对物品4239的评分：3.82783\n",
      "开始预测用户1对电影4246的评分...\n",
      "预测出用户1对物品4246的评分：3.50353\n",
      "开始预测用户1对电影4247的评分...\n",
      "预测出用户1对物品4247的评分：2.20234\n",
      "开始预测用户1对电影4254的评分...\n",
      "预测出用户1对物品4254的评分：1.73146\n",
      "开始预测用户1对电影4262的评分...\n",
      "预测出用户1对物品4262的评分：3.96131\n",
      "开始预测用户1对电影4270的评分...\n",
      "预测出用户1对物品4270的评分：2.76022\n",
      "开始预测用户1对电影86190的评分...\n",
      "预测出用户1对物品86190的评分：3.64092\n",
      "开始预测用户1对电影4291的评分...\n",
      "预测出用户1对物品4291的评分：2.66405\n",
      "开始预测用户1对电影4299的评分...\n",
      "预测出用户1对物品4299的评分：3.43983\n",
      "开始预测用户1对电影4306的评分...\n",
      "预测出用户1对物品4306的评分：3.72415\n",
      "开始预测用户1对电影4308的评分...\n",
      "预测出用户1对物品4308的评分：3.79334\n",
      "开始预测用户1对电影69844的评分...\n",
      "预测出用户1对物品69844的评分：3.88377\n",
      "开始预测用户1对电影4310的评分...\n",
      "预测出用户1对物品4310的评分：2.78763\n",
      "开始预测用户1对电影53464的评分...\n",
      "预测出用户1对物品53464的评分：2.42986\n",
      "开始预测用户1对电影4321的评分...\n",
      "预测出用户1对物品4321的评分：3.38840\n",
      "开始预测用户1对电影4326的评分...\n",
      "预测出用户1对物品4326的评分：3.52653\n",
      "开始预测用户1对电影4327的评分...\n",
      "预测出用户1对物品4327的评分：3.80550\n",
      "开始预测用户1对电影176371的评分...\n",
      "预测出用户1对物品176371的评分：3.40248\n",
      "开始预测用户1对电影4340的评分...\n",
      "预测出用户1对物品4340的评分：2.18604\n",
      "开始预测用户1对电影4343的评分...\n",
      "预测出用户1对物品4343的评分：2.89330\n",
      "开始预测用户1对电影4344的评分...\n",
      "预测出用户1对物品4344的评分：3.29583\n",
      "开始预测用户1对电影4351的评分...\n",
      "预测出用户1对物品4351的评分：3.19297\n",
      "开始预测用户1对电影4361的评分...\n",
      "预测出用户1对物品4361的评分：3.43196\n",
      "开始预测用户1对电影4366的评分...\n",
      "预测出用户1对物品4366的评分：3.41521\n",
      "开始预测用户1对电影4367的评分...\n",
      "预测出用户1对物品4367的评分：2.35073\n",
      "开始预测用户1对电影4368的评分...\n",
      "预测出用户1对物品4368的评分：2.65792\n",
      "开始预测用户1对电影4369的评分...\n",
      "预测出用户1对物品4369的评分：2.80270\n",
      "开始预测用户1对电影4370的评分...\n",
      "预测出用户1对物品4370的评分：3.32476\n",
      "开始预测用户1对电影53519的评分...\n",
      "预测出用户1对物品53519的评分：3.04519\n",
      "开始预测用户1对电影78105的评分...\n",
      "预测出用户1对物品78105的评分：2.53786\n",
      "开始预测用户1对电影4378的评分...\n",
      "预测出用户1对物品4378的评分：3.73989\n",
      "开始预测用户1对电影4386的评分...\n",
      "预测出用户1对物品4386的评分：2.39853\n",
      "开始预测用户1对电影4388的评分...\n",
      "预测出用户1对物品4388的评分：2.61966\n",
      "开始预测用户1对电影168250的评分...\n",
      "预测出用户1对物品168250的评分：3.39909\n",
      "开始预测用户1对电影86332的评分...\n",
      "预测出用户1对物品86332的评分：3.48778\n",
      "开始预测用户1对电影168252的评分...\n",
      "预测出用户1对物品168252的评分：4.51528\n",
      "开始预测用户1对电影69951的评分...\n",
      "预测出用户1对物品69951的评分：4.05412\n",
      "开始预测用户1对电影4446的评分...\n",
      "预测出用户1对物品4446的评分：3.25640\n",
      "开始预测用户1对电影4447的评分...\n",
      "预测出用户1对物品4447的评分：2.90532\n",
      "开始预测用户1对电影4448的评分...\n",
      "预测出用户1对物品4448的评分：3.59803\n",
      "开始预测用户1对电影119141的评分...\n",
      "预测出用户1对物品119141的评分：3.45994\n",
      "开始预测用户1对电影119145的评分...\n",
      "预测出用户1对物品119145的评分：4.06295\n",
      "开始预测用户1对电影135536的评分...\n",
      "预测出用户1对物品135536的评分：3.16302\n",
      "开始预测用户1对电影4467的评分...\n",
      "预测出用户1对物品4467的评分：3.84553\n",
      "开始预测用户1对电影45431的评分...\n",
      "预测出用户1对物品45431的评分：3.36798\n",
      "开始预测用户1对电影4487的评分...\n",
      "预测出用户1对物品4487的评分：2.63943\n",
      "开始预测用户1对电影45447的评分...\n",
      "预测出用户1对物品45447的评分：3.18435\n",
      "开始预测用户1对电影4489的评分...\n",
      "预测出用户1对物品4489的评分：3.39533\n",
      "开始预测用户1对电影135569的评分...\n",
      "预测出用户1对物品135569的评分：3.44969\n",
      "开始预测用户1对电影4499的评分...\n",
      "预测出用户1对物品4499的评分：4.28897\n",
      "开始预测用户1对电影45499的评分...\n",
      "预测出用户1对物品45499的评分：3.10397\n",
      "开始预测用户1对电影45501的评分...\n",
      "预测出用户1对物品45501的评分：2.59526\n",
      "开始预测用户1对电影4545的评分...\n",
      "预测出用户1对物品4545的评分：3.17788\n",
      "开始预测用户1对电影45517的评分...\n",
      "预测出用户1对物品45517的评分：3.32538\n",
      "开始预测用户1对电影4558的评分...\n",
      "预测出用户1对物品4558的评分：2.20643\n",
      "开始预测用户1对电影94677的评分...\n",
      "预测出用户1对物品94677的评分：3.99103\n",
      "开始预测用户1对电影4571的评分...\n",
      "预测出用户1对物品4571的评分：3.65699\n",
      "开始预测用户1对电影102903的评分...\n",
      "预测出用户1对物品102903的评分：3.98152\n",
      "开始预测用户1对电影37384的评分...\n",
      "预测出用户1对物品37384的评分：3.00076\n",
      "开始预测用户1对电影111113的评分...\n",
      "预测出用户1对物品111113的评分：3.73420\n",
      "开始预测用户1对电影37386的评分...\n",
      "预测出用户1对物品37386的评分：2.32070\n",
      "开始预测用户1对电影4621的评分...\n",
      "预测出用户1对物品4621的评分：2.12835\n",
      "开始预测用户1对电影152077的评分...\n",
      "预测出用户1对物品152077的评分：3.71843\n",
      "开始预测用户1对电影4623的评分...\n",
      "预测出用户1对物品4623的评分：3.59836\n",
      "开始预测用户1对电影152081的评分...\n",
      "预测出用户1对物品152081的评分：3.97831\n",
      "开始预测用户1对电影4638的评分...\n",
      "预测出用户1对物品4638的评分：2.54196\n",
      "开始预测用户1对电影4639的评分...\n",
      "预测出用户1对物品4639的评分：2.52049\n",
      "开始预测用户1对电影4641的评分...\n",
      "预测出用户1对物品4641的评分：3.60518\n",
      "开始预测用户1对电影4642的评分...\n",
      "预测出用户1对物品4642的评分：4.16018\n",
      "开始预测用户1对电影4643的评分...\n",
      "预测出用户1对物品4643的评分：2.79306\n",
      "开始预测用户1对电影70183的评分...\n",
      "预测出用户1对物品70183的评分：3.68374\n",
      "开始预测用户1对电影94777的评分...\n",
      "预测出用户1对物品94777的评分：3.32046\n",
      "开始预测用户1对电影4677的评分...\n",
      "预测出用户1对物品4677的评分：2.91767\n",
      "开始预测用户1对电影4679的评分...\n",
      "预测出用户1对物品4679的评分：2.86634\n",
      "开始预测用户1对电影4700的评分...\n",
      "预测出用户1对物品4700的评分：3.26557\n",
      "开始预测用户1对电影4701的评分...\n",
      "预测出用户1对物品4701的评分：3.18663\n",
      "开始预测用户1对电影45666的评分...\n",
      "预测出用户1对物品45666的评分：2.33371\n",
      "开始预测用户1对电影45672的评分...\n",
      "预测出用户1对物品45672的评分：3.03904\n",
      "开始预测用户1对电影4718的评分...\n",
      "预测出用户1对物品4718的评分：2.96537\n",
      "开始预测用户1对电影4720的评分...\n",
      "预测出用户1对物品4720的评分：3.37114\n",
      "开始预测用户1对电影4728的评分...\n",
      "预测出用户1对物品4728的评分：2.92746\n",
      "开始预测用户1对电影4734的评分...\n",
      "预测出用户1对物品4734的评分：2.95178\n",
      "开始预测用户1对电影103042的评分...\n",
      "预测出用户1对物品103042的评分：3.24876\n",
      "开始预测用户1对电影78469的评分...\n",
      "预测出用户1对物品78469的评分：3.00954\n",
      "开始预测用户1对电影53894的评分...\n",
      "预测出用户1对物品53894的评分：3.67725\n",
      "开始预测用户1对电影70286的评分...\n",
      "预测出用户1对物品70286的评分：3.65852\n",
      "开始预测用户1对电影94864的评分...\n",
      "预测出用户1对物品94864的评分：3.03651\n",
      "开始预测用户1对电影70293的评分...\n",
      "预测出用户1对物品70293的评分：2.60700\n",
      "开始预测用户1对电影45720的评分...\n",
      "预测出用户1对物品45720的评分：3.72554\n",
      "开始预测用户1对电影45722的评分...\n",
      "预测出用户1对物品45722的评分：3.40243\n",
      "开始预测用户1对电影45728的评分...\n",
      "预测出用户1对物品45728的评分：3.95508\n",
      "开始预测用户1对电影78499的评分...\n",
      "预测出用户1对物品78499的评分：3.90893\n",
      "开始预测用户1对电影4776的评分...\n",
      "预测出用户1对物品4776的评分：3.70286\n",
      "开始预测用户1对电影53953的评分...\n",
      "预测出用户1对物品53953的评分：2.92764\n",
      "开始预测用户1对电影135887的评分...\n",
      "预测出用户1对物品135887的评分：3.53095\n",
      "开始预测用户1对电影4816的评分...\n",
      "预测出用户1对物品4816的评分：3.58811\n",
      "开始预测用户1对电影53972的评分...\n",
      "预测出用户1对物品53972的评分：3.43041\n",
      "开始预测用户1对电影4823的评分...\n",
      "预测出用户1对物品4823的评分：3.18712\n",
      "开始预测用户1对电影103141的评分...\n",
      "预测出用户1对物品103141的评分：4.08750\n",
      "开始预测用户1对电影53993的评分...\n",
      "预测出用户1对物品53993的评分：2.91075\n",
      "开始预测用户1对电影53996的评分...\n",
      "预测出用户1对物品53996的评分：3.57827\n",
      "开始预测用户1对电影94959的评分...\n",
      "预测出用户1对物品94959的评分：3.79991\n",
      "开始预测用户1对电影4848的评分...\n",
      "预测出用户1对物品4848的评分：3.63635\n",
      "开始预测用户1对电影54001的评分...\n",
      "预测出用户1对物品54001的评分：3.92834\n",
      "开始预测用户1对电影54004的评分...\n",
      "预测出用户1对物品54004的评分：3.66518\n",
      "开始预测用户1对电影4855的评分...\n",
      "预测出用户1对物品4855的评分：3.77218\n",
      "开始预测用户1对电影111360的评分...\n",
      "预测出用户1对物品111360的评分：2.98305\n",
      "开始预测用户1对电影4865的评分...\n",
      "预测出用户1对物品4865的评分：3.48412\n",
      "开始预测用户1对电影111362的评分...\n",
      "预测出用户1对物品111362的评分：4.00169\n",
      "开始预测用户1对电影111364的评分...\n",
      "预测出用户1对物品111364的评分：2.86637\n",
      "开始预测用户1对电影4873的评分...\n",
      "预测出用户1对物品4873的评分：3.98821\n",
      "开始预测用户1对电影4874的评分...\n",
      "预测出用户1对物品4874的评分：3.42615\n",
      "开始预测用户1对电影4876的评分...\n",
      "预测出用户1对物品4876的评分：2.47508\n",
      "开始预测用户1对电影4878的评分...\n",
      "预测出用户1对物品4878的评分：3.96270\n",
      "开始预测用户1对电影4881的评分...\n",
      "预测出用户1对物品4881的评分：3.75398\n",
      "开始预测用户1对电影4886的评分...\n",
      "预测出用户1对物品4886的评分：3.90056\n",
      "开始预测用户1对电影4887的评分...\n",
      "预测出用户1对物品4887的评分：2.29970\n",
      "开始预测用户1对电影4890的评分...\n",
      "预测出用户1对物品4890的评分：2.93452\n",
      "开始预测用户1对电影4896的评分...\n",
      "预测出用户1对物品4896的评分：3.74943\n",
      "开始预测用户1对电影4901的评分...\n",
      "预测出用户1对物品4901的评分：3.49793\n",
      "开始预测用户1对电影86833的评分...\n",
      "预测出用户1对物品86833的评分：4.04410\n",
      "开始预测用户1对电影45880的评分...\n",
      "预测出用户1对物品45880的评分：2.90168\n",
      "开始预测用户1对电影103228的评分...\n",
      "预测出用户1对物品103228的评分：3.42930\n",
      "开始预测用户1对电影103249的评分...\n",
      "预测出用户1对物品103249的评分：2.99123\n",
      "开始预测用户1对电影136020的评分...\n",
      "预测出用户1对物品136020的评分：3.07302\n",
      "开始预测用户1对电影103253的评分...\n",
      "预测出用户1对物品103253的评分：3.33008\n",
      "开始预测用户1对电影4954的评分...\n",
      "预测出用户1对物品4954的评分：3.63613\n",
      "开始预测用户1对电影4958的评分...\n",
      "预测出用户1对物品4958的评分：3.40495\n",
      "开始预测用户1对电影37727的评分...\n",
      "预测出用户1对物品37727的评分：2.71406\n",
      "开始预测用户1对电影86880的评分...\n",
      "预测出用户1对物品86880的评分：3.37965\n",
      "开始预测用户1对电影37729的评分...\n",
      "预测出用户1对物品37729的评分：3.64817\n",
      "开始预测用户1对电影86882的评分...\n",
      "预测出用户1对物品86882的评分：3.80076\n",
      "开始预测用户1对电影4963的评分...\n",
      "预测出用户1对物品4963的评分：3.80787\n",
      "开始预测用户1对电影37733的评分...\n",
      "预测出用户1对物品37733的评分：3.45489\n",
      "开始预测用户1对电影4967的评分...\n",
      "预测出用户1对物品4967的评分：4.31707\n",
      "开始预测用户1对电影4973的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品4973的评分：4.22948\n",
      "开始预测用户1对电影4974的评分...\n",
      "预测出用户1对物品4974的评分：2.39854\n",
      "开始预测用户1对电影4975的评分...\n",
      "预测出用户1对物品4975的评分：3.41415\n",
      "开始预测用户1对电影37741的评分...\n",
      "预测出用户1对物品37741的评分：3.90017\n",
      "开始预测用户1对电影4979的评分...\n",
      "预测出用户1对物品4979的评分：3.82452\n",
      "开始预测用户1对电影4980的评分...\n",
      "预测出用户1对物品4980的评分：2.92925\n",
      "开始预测用户1对电影45950的评分...\n",
      "预测出用户1对物品45950的评分：3.57881\n",
      "开始预测用户1对电影86911的评分...\n",
      "预测出用户1对物品86911的评分：3.09538\n",
      "开始预测用户1对电影4992的评分...\n",
      "预测出用户1对物品4992的评分：3.30689\n",
      "开始预测用户1对电影4993的评分...\n",
      "预测出用户1对物品4993的评分：4.19182\n",
      "开始预测用户1对电影4995的评分...\n",
      "预测出用户1对物品4995的评分：4.02851\n",
      "开始预测用户1对电影5010的评分...\n",
      "预测出用户1对物品5010的评分：3.56667\n",
      "开始预测用户1对电影5013的评分...\n",
      "预测出用户1对物品5013的评分：3.82490\n",
      "开始预测用户1对电影5014的评分...\n",
      "预测出用户1对物品5014的评分：4.06036\n",
      "开始预测用户1对电影5015的评分...\n",
      "预测出用户1对物品5015的评分：3.49168\n",
      "开始预测用户1对电影5025的评分...\n",
      "预测出用户1对物品5025的评分：2.52316\n",
      "开始预测用户1对电影5026的评分...\n",
      "预测出用户1对物品5026的评分：3.60283\n",
      "开始预测用户1对电影62374的评分...\n",
      "预测出用户1对物品62374的评分：4.13279\n",
      "开始预测用户1对电影103335的评分...\n",
      "预测出用户1对物品103335的评分：3.95848\n",
      "开始预测用户1对电影103341的评分...\n",
      "预测出用户1对物品103341的评分：3.81589\n",
      "开始预测用户1对电影54190的评分...\n",
      "预测出用户1对物品54190的评分：4.04063\n",
      "开始预测用户1对电影5049的评分...\n",
      "预测出用户1对物品5049的评分：3.40386\n",
      "开始预测用户1对电影95167的评分...\n",
      "预测出用户1对物品95167的评分：3.59123\n",
      "开始预测用户1对电影5064的评分...\n",
      "预测出用户1对物品5064的评分：3.84435\n",
      "开始预测用户1对电影5065的评分...\n",
      "预测出用户1对物品5065的评分：2.99728\n",
      "开始预测用户1对电影5066的评分...\n",
      "预测出用户1对物品5066的评分：3.11333\n",
      "开始预测用户1对电影5072的评分...\n",
      "预测出用户1对物品5072的评分：3.90452\n",
      "开始预测用户1对电影62434的评分...\n",
      "预测出用户1对物品62434的评分：3.80159\n",
      "开始预测用户1对电影5103的评分...\n",
      "预测出用户1对物品5103的评分：3.26684\n",
      "开始预测用户1对电影54259的评分...\n",
      "预测出用户1对物品54259的评分：3.53249\n",
      "开始预测用户1对电影5108的评分...\n",
      "预测出用户1对物品5108的评分：3.10886\n",
      "开始预测用户1对电影5110的评分...\n",
      "预测出用户1对物品5110的评分：3.58744\n",
      "开始预测用户1对电影54272的评分...\n",
      "预测出用户1对物品54272的评分：3.82958\n",
      "开始预测用户1对电影5128的评分...\n",
      "预测出用户1对物品5128的评分：2.43334\n",
      "开始预测用户1对电影54286的评分...\n",
      "预测出用户1对物品54286的评分：3.50230\n",
      "开始预测用户1对电影5135的评分...\n",
      "预测出用户1对物品5135的评分：3.64477\n",
      "开始预测用户1对电影5151的评分...\n",
      "预测出用户1对物品5151的评分：3.07844\n",
      "开始预测用户1对电影5152的评分...\n",
      "预测出用户1对物品5152的评分：3.13780\n",
      "开始预测用户1对电影111659的评分...\n",
      "预测出用户1对物品111659的评分：3.13183\n",
      "开始预测用户1对电影5171的评分...\n",
      "预测出用户1对物品5171的评分：2.81700\n",
      "开始预测用户1对电影5218的评分...\n",
      "预测出用户1对物品5218的评分：3.73442\n",
      "开始预测用户1对电影5219的评分...\n",
      "预测出用户1对物品5219的评分：3.00570\n",
      "开始预测用户1对电影5225的评分...\n",
      "预测出用户1对物品5225的评分：4.06752\n",
      "开始预测用户1对电影111743的评分...\n",
      "预测出用户1对物品111743的评分：3.24703\n",
      "开始预测用户1对电影5254的评分...\n",
      "预测出用户1对物品5254的评分：2.94634\n",
      "开始预测用户1对电影111759的评分...\n",
      "预测出用户1对物品111759的评分：3.97756\n",
      "开始预测用户1对电影5265的评分...\n",
      "预测出用户1对物品5265的评分：3.02756\n",
      "开始预测用户1对电影5266的评分...\n",
      "预测出用户1对物品5266的评分：3.14822\n",
      "开始预测用户1对电影5267的评分...\n",
      "预测出用户1对物品5267的评分：3.42206\n",
      "开始预测用户1对电影38038的评分...\n",
      "预测出用户1对物品38038的评分：3.73674\n",
      "开始预测用户1对电影5283的评分...\n",
      "预测出用户1对物品5283的评分：2.87177\n",
      "开始预测用户1对电影111781的评分...\n",
      "预测出用户1对物品111781的评分：3.35496\n",
      "开始预测用户1对电影5291的评分...\n",
      "预测出用户1对物品5291的评分：4.05045\n",
      "开始预测用户1对电影38061的评分...\n",
      "预测出用户1对物品38061的评分：4.17349\n",
      "开始预测用户1对电影5294的评分...\n",
      "预测出用户1对物品5294的评分：3.60923\n",
      "开始预测用户1对电影5299的评分...\n",
      "预测出用户1对物品5299的评分：3.12355\n",
      "开始预测用户1对电影87222的评分...\n",
      "预测出用户1对物品87222的评分：3.55552\n",
      "开始预测用户1对电影5308的评分...\n",
      "预测出用户1对物品5308的评分：2.98512\n",
      "开始预测用户1对电影87232的评分...\n",
      "预测出用户1对物品87232的评分：3.93125\n",
      "开始预测用户1对电影5313的评分...\n",
      "预测出用户1对物品5313的评分：1.72830\n",
      "开始预测用户1对电影95441的评分...\n",
      "预测出用户1对物品95441的评分：3.27487\n",
      "开始预测用户1对电影5349的评分...\n",
      "预测出用户1对物品5349的评分：3.58489\n",
      "开始预测用户1对电影54503的评分...\n",
      "预测出用户1对物品54503的评分：4.12585\n",
      "开始预测用户1对电影79091的评分...\n",
      "预测出用户1对物品79091的评分：3.66613\n",
      "开始预测用户1对电影46335的评分...\n",
      "预测出用户1对物品46335的评分：2.05727\n",
      "开始预测用户1对电影5377的评分...\n",
      "预测出用户1对物品5377的评分：3.73072\n",
      "开始预测用户1对电影5378的评分...\n",
      "预测出用户1对物品5378的评分：3.16993\n",
      "开始预测用户1对电影87306的评分...\n",
      "预测出用户1对物品87306的评分：3.72900\n",
      "开始预测用户1对电影5388的评分...\n",
      "预测出用户1对物品5388的评分：3.34386\n",
      "开始预测用户1对电影95510的评分...\n",
      "预测出用户1对物品95510的评分：2.85124\n",
      "开始预测用户1对电影5400的评分...\n",
      "预测出用户1对物品5400的评分：2.85330\n",
      "开始预测用户1对电影79132的评分...\n",
      "预测出用户1对物品79132的评分：4.22976\n",
      "开始预测用户1对电影5418的评分...\n",
      "预测出用户1对物品5418的评分：3.72253\n",
      "开始预测用户1对电影5419的评分...\n",
      "预测出用户1对物品5419的评分：2.52701\n",
      "开始预测用户1对电影5444的评分...\n",
      "预测出用户1对物品5444的评分：3.95919\n",
      "开始预测用户1对电影5445的评分...\n",
      "预测出用户1对物品5445的评分：3.58888\n",
      "开始预测用户1对电影5449的评分...\n",
      "预测出用户1对物品5449的评分：2.96857\n",
      "开始预测用户1对电影5459的评分...\n",
      "预测出用户1对物品5459的评分：2.74399\n",
      "开始预测用户1对电影5463的评分...\n",
      "预测出用户1对物品5463的评分：2.48470\n",
      "开始预测用户1对电影5464的评分...\n",
      "预测出用户1对物品5464的评分：3.50519\n",
      "开始预测用户1对电影103772的评分...\n",
      "预测出用户1对物品103772的评分：3.58883\n",
      "开始预测用户1对电影128360的评分...\n",
      "预测出用户1对物品128360的评分：4.14445\n",
      "开始预测用户1对电影5481的评分...\n",
      "预测出用户1对物品5481的评分：2.79117\n",
      "开始预测用户1对电影5502的评分...\n",
      "预测出用户1对物品5502的评分：3.06887\n",
      "开始预测用户1对电影5505的评分...\n",
      "预测出用户1对物品5505的评分：3.48454\n",
      "开始预测用户1对电影62849的评分...\n",
      "预测出用户1对物品62849的评分：3.78733\n",
      "开始预测用户1对电影5507的评分...\n",
      "预测出用户1对物品5507的评分：2.31879\n",
      "开始预测用户1对电影71057的评分...\n",
      "预测出用户1对物品71057的评分：3.74522\n",
      "开始预测用户1对电影5528的评分...\n",
      "预测出用户1对物品5528的评分：3.58334\n",
      "开始预测用户1对电影5541的评分...\n",
      "预测出用户1对物品5541的评分：3.14194\n",
      "开始预测用户1对电影79293的评分...\n",
      "预测出用户1对物品79293的评分：2.51583\n",
      "开始预测用户1对电影46530的评分...\n",
      "预测出用户1对物品46530的评分：2.89603\n",
      "开始预测用户1对电影5574的评分...\n",
      "预测出用户1对物品5574的评分：3.18336\n",
      "开始预测用户1对电影5577的评分...\n",
      "预测出用户1对物品5577的评分：3.97012\n",
      "开始预测用户1对电影87520的评分...\n",
      "预测出用户1对物品87520的评分：1.98670\n",
      "开始预测用户1对电影5608的评分...\n",
      "预测出用户1对物品5608的评分：4.09442\n",
      "开始预测用户1对电影5617的评分...\n",
      "预测出用户1对物品5617的评分：4.02025\n",
      "开始预测用户1对电影5618的评分...\n",
      "预测出用户1对物品5618的评分：4.40641\n",
      "开始预测用户1对电影46578的评分...\n",
      "预测出用户1对物品46578的评分：4.15035\n",
      "开始预测用户1对电影5620的评分...\n",
      "预测出用户1对物品5620的评分：3.03161\n",
      "开始预测用户1对电影5630的评分...\n",
      "预测出用户1对物品5630的评分：3.55674\n",
      "开始预测用户1对电影112138的评分...\n",
      "预测出用户1对物品112138的评分：3.74220\n",
      "开始预测用户1对电影5650的评分...\n",
      "预测出用户1对物品5650的评分：3.78399\n",
      "开始预测用户1对电影62999的评分...\n",
      "预测出用户1对物品62999的评分：3.73930\n",
      "开始预测用户1对电影5669的评分...\n",
      "预测出用户1对物品5669的评分：3.81218\n",
      "开始预测用户1对电影5673的评分...\n",
      "预测出用户1对物品5673的评分：3.76873\n",
      "开始预测用户1对电影5679的评分...\n",
      "预测出用户1对物品5679的评分：3.08249\n",
      "开始预测用户1对电影112175的评分...\n",
      "预测出用户1对物品112175的评分：4.34568\n",
      "开始预测用户1对电影112183的评分...\n",
      "预测出用户1对物品112183的评分：3.55897\n",
      "开始预测用户1对电影5690的评分...\n",
      "预测出用户1对物品5690的评分：3.96573\n",
      "开始预测用户1对电影5693的评分...\n",
      "预测出用户1对物品5693的评分：3.18185\n",
      "开始预测用户1对电影71264的评分...\n",
      "预测出用户1对物品71264的评分：4.02935\n",
      "开始预测用户1对电影54881的评分...\n",
      "预测出用户1对物品54881的评分：3.75229\n",
      "开始预测用户1对电影177765的评分...\n",
      "预测出用户1对物品177765的评分：3.63079\n",
      "开始预测用户1对电影63082的评分...\n",
      "预测出用户1对物品63082的评分：3.99287\n",
      "开始预测用户1对电影46723的评分...\n",
      "预测出用户1对物品46723的评分：3.46269\n",
      "开始预测用户1对电影63113的评分...\n",
      "预测出用户1对物品63113的评分：3.65543\n",
      "开始预测用户1对电影5782的评分...\n",
      "预测出用户1对物品5782的评分：4.05999\n",
      "开始预测用户1对电影5785的评分...\n",
      "预测出用户1对物品5785的评分：3.63711\n",
      "开始预测用户1对电影63131的评分...\n",
      "预测出用户1对物品63131的评分：3.77826\n",
      "开始预测用户1对电影5791的评分...\n",
      "预测出用户1对物品5791的评分：3.73505\n",
      "开始预测用户1对电影136864的评分...\n",
      "预测出用户1对物品136864的评分：3.14017\n",
      "开始预测用户1对电影112290的评分...\n",
      "预测出用户1对物品112290的评分：4.30531\n",
      "开始预测用户1对电影5810的评分...\n",
      "预测出用户1对物品5810的评分：3.14828\n",
      "开始预测用户1对电影5812的评分...\n",
      "预测出用户1对物品5812的评分：3.94226\n",
      "开始预测用户1对电影5816的评分...\n",
      "预测出用户1对物品5816的评分：3.63770\n",
      "开始预测用户1对电影54995的评分...\n",
      "预测出用户1对物品54995的评分：3.20091\n",
      "开始预测用户1对电影54997的评分...\n",
      "预测出用户1对物品54997的评分：4.14802\n",
      "开始预测用户1对电影54999的评分...\n",
      "预测出用户1对物品54999的评分：3.02711\n",
      "开始预测用户1对电影79592的评分...\n",
      "预测出用户1对物品79592的评分：3.27508\n",
      "开始预测用户1对电影5872的评分...\n",
      "预测出用户1对物品5872的评分：2.85356\n",
      "开始预测用户1对电影5878的评分...\n",
      "预测出用户1对物品5878的评分：4.17368\n",
      "开始预测用户1对电影5881的评分...\n",
      "预测出用户1对物品5881的评分：2.82226\n",
      "开始预测用户1对电影55052的评分...\n",
      "预测出用户1对物品55052的评分：3.56655\n",
      "开始预测用户1对电影5902的评分...\n",
      "预测出用户1对物品5902的评分：4.28083\n",
      "开始预测用户1对电影5903的评分...\n",
      "预测出用户1对物品5903的评分：3.77064\n",
      "开始预测用户1对电影104211的评分...\n",
      "预测出用户1对物品104211的评分：3.55618\n",
      "开始预测用户1对电影71464的评分...\n",
      "预测出用户1对物品71464的评分：3.46646\n",
      "开始预测用户1对电影104241的评分...\n",
      "预测出用户1对物品104241的评分：3.44886\n",
      "开始预测用户1对电影5943的评分...\n",
      "预测出用户1对物品5943的评分：2.43811\n",
      "开始预测用户1对电影5944的评分...\n",
      "预测出用户1对物品5944的评分：3.15381\n",
      "开始预测用户1对电影5945的评分...\n",
      "预测出用户1对物品5945的评分：3.03809\n",
      "开始预测用户1对电影87869的评分...\n",
      "预测出用户1对物品87869的评分：3.26982\n",
      "开始预测用户1对电影5952的评分...\n",
      "预测出用户1对物品5952的评分：4.06940\n",
      "开始预测用户1对电影5954的评分...\n",
      "预测出用户1对物品5954的评分：3.75109\n",
      "开始预测用户1对电影5956的评分...\n",
      "预测出用户1对物品5956的评分：3.52768\n",
      "开始预测用户1对电影5957的评分...\n",
      "预测出用户1对物品5957的评分：2.84608\n",
      "开始预测用户1对电影55118的评分...\n",
      "预测出用户1对物品55118的评分：3.82875\n",
      "开始预测用户1对电影79695的评分...\n",
      "预测出用户1对物品79695的评分：2.84144\n",
      "开始预测用户1对电影96079的评分...\n",
      "预测出用户1对物品96079的评分：3.79781\n",
      "开始预测用户1对电影5971的评分...\n",
      "预测出用户1对物品5971的评分：4.09783\n",
      "开始预测用户1对电影79702的评分...\n",
      "预测出用户1对物品79702的评分：3.85129\n",
      "开始预测用户1对电影5989的评分...\n",
      "预测出用户1对物品5989的评分：3.94279\n",
      "开始预测用户1对电影5991的评分...\n",
      "预测出用户1对物品5991的评分：3.77367\n",
      "开始预测用户1对电影5992的评分...\n",
      "预测出用户1对物品5992的评分：3.58889\n",
      "开始预测用户1对电影71530的评分...\n",
      "预测出用户1对物品71530的评分：2.68141\n",
      "开始预测用户1对电影5995的评分...\n",
      "预测出用户1对物品5995的评分：4.22815\n",
      "开始预测用户1对电影71535的评分...\n",
      "预测出用户1对物品71535的评分：3.90637\n",
      "开始预测用户1对电影6003的评分...\n",
      "预测出用户1对物品6003的评分：3.48036\n",
      "开始预测用户1对电影46965的评分...\n",
      "预测出用户1对物品46965的评分：2.93725\n",
      "开始预测用户1对电影46970的评分...\n",
      "预测出用户1对物品46970的评分：3.04643\n",
      "开始预测用户1对电影46972的评分...\n",
      "预测出用户1对物品46972的评分：3.21678\n",
      "开始预测用户1对电影6016的评分...\n",
      "预测出用户1对物品6016的评分：3.98050\n",
      "开始预测用户1对电影46976的评分...\n",
      "预测出用户1对物品46976的评分：3.69267\n",
      "开始预测用户1对电影112552的评分...\n",
      "预测出用户1对物品112552的评分：4.03914\n",
      "开始预测用户1对电影6059的评分...\n",
      "预测出用户1对物品6059的评分：3.05552\n",
      "开始预测用户1对电影112556的评分...\n",
      "预测出用户1对物品112556的评分：3.87197\n",
      "开始预测用户1对电影104374的评分...\n",
      "预测出用户1对物品104374的评分：4.22813\n",
      "开始预测用户1对电影55247的评分...\n",
      "预测出用户1对物品55247的评分：3.91460\n",
      "开始预测用户1对电影55269的评分...\n",
      "预测出用户1对物品55269的评分：3.77311\n",
      "开始预测用户1对电影55276的评分...\n",
      "预测出用户1对物品55276的评分：3.62039\n",
      "开始预测用户1对电影112623的评分...\n",
      "预测出用户1对物品112623的评分：3.54887\n",
      "开始预测用户1对电影55282的评分...\n",
      "预测出用户1对物品55282的评分：3.07230\n",
      "开始预测用户1对电影30707的评分...\n",
      "预测出用户1对物品30707的评分：3.77768\n",
      "开始预测用户1对电影55290的评分...\n",
      "预测出用户1对物品55290的评分：3.88996\n",
      "开始预测用户1对电影47099的评分...\n",
      "预测出用户1对物品47099的评分：3.99983\n",
      "开始预测用户1对电影6155的评分...\n",
      "预测出用户1对物品6155的评分：3.25110\n",
      "开始预测用户1对电影6156的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品6156的评分：3.07911\n",
      "开始预测用户1对电影6157的评分...\n",
      "预测出用户1对物品6157的评分：2.47067\n",
      "开始预测用户1对电影30749的评分...\n",
      "预测出用户1对物品30749的评分：3.94401\n",
      "开始预测用户1对电影6188的评分...\n",
      "预测出用户1对物品6188的评分：3.68742\n",
      "开始预测用户1对电影88125的评分...\n",
      "预测出用户1对物品88125的评分：3.96606\n",
      "开始预测用户1对电影71745的评分...\n",
      "预测出用户1对物品71745的评分：2.69592\n",
      "开始预测用户1对电影88129的评分...\n",
      "预测出用户1对物品88129的评分：3.89436\n",
      "开始预测用户1对电影30793的评分...\n",
      "预测出用户1对物品30793的评分：3.05277\n",
      "开始预测用户1对电影6218的评分...\n",
      "预测出用户1对物品6218的评分：3.24939\n",
      "开始预测用户1对电影88140的评分...\n",
      "预测出用户1对物品88140的评分：3.40874\n",
      "开始预测用户1对电影30810的评分...\n",
      "预测出用户1对物品30810的评分：3.73824\n",
      "开始预测用户1对电影30812的评分...\n",
      "预测出用户1对物品30812的评分：3.49270\n",
      "开始预测用户1对电影30816的评分...\n",
      "预测出用户1对物品30816的评分：3.22884\n",
      "开始预测用户1对电影47200的评分...\n",
      "预测出用户1对物品47200的评分：3.09358\n",
      "开始预测用户1对电影6242的评分...\n",
      "预测出用户1对物品6242的评分：3.58358\n",
      "开始预测用户1对电影88163的评分...\n",
      "预测出用户1对物品88163的评分：3.99106\n",
      "开始预测用户1对电影30822的评分...\n",
      "预测出用户1对物品30822的评分：3.46327\n",
      "开始预测用户1对电影30825的评分...\n",
      "预测出用户1对物品30825的评分：3.20868\n",
      "开始预测用户1对电影6281的评分...\n",
      "预测出用户1对物品6281的评分：2.91068\n",
      "开始预测用户1对电影6283的评分...\n",
      "预测出用户1对物品6283的评分：4.05105\n",
      "开始预测用户1对电影6287的评分...\n",
      "预测出用户1对物品6287的评分：3.08297\n",
      "开始预测用户1对电影55442的评分...\n",
      "预测出用户1对物品55442的评分：4.40322\n",
      "开始预测用户1对电影6294的评分...\n",
      "预测出用户1对物品6294的评分：2.49802\n",
      "开始预测用户1对电影6296的评分...\n",
      "预测出用户1对物品6296的评分：3.51834\n",
      "开始预测用户1对电影6297的评分...\n",
      "预测出用户1对物品6297的评分：3.42652\n",
      "开始预测用户1对电影6323的评分...\n",
      "预测出用户1对物品6323的评分：3.46603\n",
      "开始预测用户1对电影6331的评分...\n",
      "预测出用户1对物品6331的评分：3.77038\n",
      "开始预测用户1对电影6333的评分...\n",
      "预测出用户1对物品6333的评分：3.70884\n",
      "开始预测用户1对电影6350的评分...\n",
      "预测出用户1对物品6350的评分：4.19110\n",
      "开始预测用户1对电影112852的评分...\n",
      "预测出用户1对物品112852的评分：4.12670\n",
      "开始预测用户1对电影6365的评分...\n",
      "预测出用户1对物品6365的评分：3.39926\n",
      "开始预测用户1对电影6373的评分...\n",
      "预测出用户1对物品6373的评分：3.31512\n",
      "开始预测用户1对电影6377的评分...\n",
      "预测出用户1对物品6377的评分：3.88059\n",
      "开始预测用户1对电影6378的评分...\n",
      "预测出用户1对物品6378的评分：3.45711\n",
      "开始预测用户1对电影6383的评分...\n",
      "预测出用户1对物品6383的评分：2.27357\n",
      "开始预测用户1对电影6385的评分...\n",
      "预测出用户1对物品6385的评分：4.21780\n",
      "开始预测用户1对电影39183的评分...\n",
      "预测出用户1对物品39183的评分：3.76479\n",
      "开始预测用户1对电影6440的评分...\n",
      "预测出用户1对物品6440的评分：4.08993\n",
      "开始预测用户1对电影72011的评分...\n",
      "预测出用户1对物品72011的评分：3.81205\n",
      "开始预测用户1对电影96588的评分...\n",
      "预测出用户1对物品96588的评分：3.30205\n",
      "开始预测用户1对电影6482的评分...\n",
      "预测出用户1对物品6482的评分：1.97807\n",
      "开始预测用户1对电影88405的评分...\n",
      "预测出用户1对物品88405的评分：3.03638\n",
      "开始预测用户1对电影80219的评分...\n",
      "预测出用户1对物品80219的评分：3.46484\n",
      "开始预测用户1对电影96610的评分...\n",
      "预测出用户1对物品96610的评分：3.73180\n",
      "开始预测用户1对电影6502的评分...\n",
      "预测出用户1对物品6502的评分：4.12220\n",
      "开始预测用户1对电影6503的评分...\n",
      "预测出用户1对物品6503的评分：2.48282\n",
      "开始预测用户1对电影63859的评分...\n",
      "预测出用户1对物品63859的评分：3.31190\n",
      "开始预测用户1对电影39292的评分...\n",
      "预测出用户1对物品39292的评分：3.70701\n",
      "开始预测用户1对电影63876的评分...\n",
      "预测出用户1对物品63876的评分：3.69847\n",
      "开始预测用户1对电影6534的评分...\n",
      "预测出用户1对物品6534的评分：2.75875\n",
      "开始预测用户1对电影6535的评分...\n",
      "预测出用户1对物品6535的评分：2.01389\n",
      "开始预测用户1对电影6537的评分...\n",
      "预测出用户1对物品6537的评分：2.91685\n",
      "开始预测用户1对电影104841的评分...\n",
      "预测出用户1对物品104841的评分：3.94350\n",
      "开始预测用户1对电影6539的评分...\n",
      "预测出用户1对物品6539的评分：3.75563\n",
      "开始预测用户1对电影6541的评分...\n",
      "预测出用户1对物品6541的评分：2.71406\n",
      "开始预测用户1对电影6548的评分...\n",
      "预测出用户1对物品6548的评分：2.97572\n",
      "开始预测用户1对电影6550的评分...\n",
      "预测出用户1对物品6550的评分：2.73172\n",
      "开始预测用户1对电影6552的评分...\n",
      "预测出用户1对物品6552的评分：3.59342\n",
      "开始预测用户1对电影47518的评分...\n",
      "预测出用户1对物品47518的评分：2.43895\n",
      "开始预测用户1对电影6564的评分...\n",
      "预测出用户1对物品6564的评分：2.70786\n",
      "开始预测用户1对电影6565的评分...\n",
      "预测出用户1对物品6565的评分：3.80917\n",
      "开始预测用户1对电影104879的评分...\n",
      "预测出用户1对物品104879的评分：3.85236\n",
      "开始预测用户1对电影6586的评分...\n",
      "预测出用户1对物品6586的评分：2.95458\n",
      "开始预测用户1对电影6593的评分...\n",
      "预测出用户1对物品6593的评分：3.13144\n",
      "开始预测用户1对电影6595的评分...\n",
      "预测出用户1对物品6595的评分：3.06758\n",
      "开始预测用户1对电影104913的评分...\n",
      "预测出用户1对物品104913的评分：4.04174\n",
      "开始预测用户1对电影55765的评分...\n",
      "预测出用户1对物品55765的评分：4.20315\n",
      "开始预测用户1对电影6618的评分...\n",
      "预测出用户1对物品6618的评分：3.79171\n",
      "开始预测用户1对电影6620的评分...\n",
      "预测出用户1对物品6620的评分：3.93727\n",
      "开始预测用户1对电影96737的评分...\n",
      "预测出用户1对物品96737的评分：3.57433\n",
      "开始预测用户1对电影63992的评分...\n",
      "预测出用户1对物品63992的评分：2.07532\n",
      "开始预测用户1对电影47610的评分...\n",
      "预测出用户1对物品47610的评分：3.81210\n",
      "开始预测用户1对电影6659的评分...\n",
      "预测出用户1对物品6659的评分：3.22859\n",
      "开始预测用户1对电影6662的评分...\n",
      "预测出用户1对物品6662的评分：3.53202\n",
      "开始预测用户1对电影55820的评分...\n",
      "预测出用户1对物品55820的评分：3.93774\n",
      "开始预测用户1对电影47629的评分...\n",
      "预测出用户1对物品47629的评分：3.67186\n",
      "开始预测用户1对电影39446的评分...\n",
      "预测出用户1对物品39446的评分：2.59469\n",
      "开始预测用户1对电影72226的评分...\n",
      "预测出用户1对物品72226的评分：4.31825\n",
      "开始预测用户1对电影6708的评分...\n",
      "预测出用户1对物品6708的评分：3.65873\n",
      "开始预测用户1对电影6709的评分...\n",
      "预测出用户1对物品6709的评分：3.19118\n",
      "开始预测用户1对电影96821的评分...\n",
      "预测出用户1对物品96821的评分：4.30417\n",
      "开始预测用户1对电影6711的评分...\n",
      "预测出用户1对物品6711的评分：4.01059\n",
      "开始预测用户1对电影80463的评分...\n",
      "预测出用户1对物品80463的评分：3.95625\n",
      "开始预测用户1对电影6753的评分...\n",
      "预测出用户1对物品6753的评分：3.39679\n",
      "开始预测用户1对电影6754的评分...\n",
      "预测出用户1对物品6754的评分：3.46038\n",
      "开始预测用户1对电影6755的评分...\n",
      "预测出用户1对物品6755的评分：3.34924\n",
      "开始预测用户1对电影80489的评分...\n",
      "预测出用户1对物品80489的评分：4.07589\n",
      "开始预测用户1对电影6764的评分...\n",
      "预测出用户1对物品6764的评分：3.14446\n",
      "开始预测用户1对电影6773的评分...\n",
      "预测出用户1对物品6773的评分：3.51735\n",
      "开始预测用户1对电影137857的评分...\n",
      "预测出用户1对物品137857的评分：3.58682\n",
      "开始预测用户1对电影6787的评分...\n",
      "预测出用户1对物品6787的评分：4.04718\n",
      "开始预测用户1对电影6793的评分...\n",
      "预测出用户1对物品6793的评分：1.91644\n",
      "开始预测用户1对电影6796的评分...\n",
      "预测出用户1对物品6796的评分：3.84104\n",
      "开始预测用户1对电影6807的评分...\n",
      "预测出用户1对物品6807的评分：4.12013\n",
      "开始预测用户1对电影80549的评分...\n",
      "预测出用户1对物品80549的评分：3.66578\n",
      "开始预测用户1对电影88744的评分...\n",
      "预测出用户1对物品88744的评分：3.08193\n",
      "开始预测用户1对电影31410的评分...\n",
      "预测出用户1对物品31410的评分：3.93840\n",
      "开始预测用户1对电影72378的评分...\n",
      "预测出用户1对物品72378的评分：2.53533\n",
      "开始预测用户1对电影6857的评分...\n",
      "预测出用户1对物品6857的评分：3.82732\n",
      "开始预测用户1对电影31433的评分...\n",
      "预测出用户1对物品31433的评分：2.95925\n",
      "开始预测用户1对电影6863的评分...\n",
      "预测出用户1对物品6863的评分：3.34537\n",
      "开始预测用户1对电影6867的评分...\n",
      "预测出用户1对物品6867的评分：3.99095\n",
      "开始预测用户1对电影6870的评分...\n",
      "预测出用户1对物品6870的评分：3.73280\n",
      "开始预测用户1对电影6873的评分...\n",
      "预测出用户1对物品6873的评分：3.10169\n",
      "开始预测用户1对电影6874的评分...\n",
      "预测出用户1对物品6874的评分：3.98951\n",
      "开始预测用户1对电影6879的评分...\n",
      "预测出用户1对物品6879的评分：3.57025\n",
      "开始预测用户1对电影6888的评分...\n",
      "预测出用户1对物品6888的评分：2.09869\n",
      "开始预测用户1对电影88810的评分...\n",
      "预测出用户1对物品88810的评分：3.68792\n",
      "开始预测用户1对电影6934的评分...\n",
      "预测出用户1对物品6934的评分：3.27711\n",
      "开始预测用户1对电影6936的评分...\n",
      "预测出用户1对物品6936的评分：3.67608\n",
      "开始预测用户1对电影6942的评分...\n",
      "预测出用户1对物品6942的评分：3.80658\n",
      "开始预测用户1对电影6944的评分...\n",
      "预测出用户1对物品6944的评分：3.49524\n",
      "开始预测用户1对电影6947的评分...\n",
      "预测出用户1对物品6947的评分：3.57811\n",
      "开始预测用户1对电影6953的评分...\n",
      "预测出用户1对物品6953的评分：3.40502\n",
      "开始预测用户1对电影6957的评分...\n",
      "预测出用户1对物品6957的评分：3.22250\n",
      "开始预测用户1对电影138036的评分...\n",
      "预测出用户1对物品138036的评分：3.91317\n",
      "开始预测用户1对电影6979的评分...\n",
      "预测出用户1对物品6979的评分：3.10575\n",
      "开始预测用户1对电影6993的评分...\n",
      "预测出用户1对物品6993的评分：3.82802\n",
      "开始预测用户1对电影56145的评分...\n",
      "预测出用户1对物品56145的评分：3.15889\n",
      "开始预测用户1对电影56152的评分...\n",
      "预测出用户1对物品56152的评分：3.49252\n",
      "开始预测用户1对电影7004的评分...\n",
      "预测出用户1对物品7004的评分：2.74394\n",
      "开始预测用户1对电影56171的评分...\n",
      "预测出用户1对物品56171的评分：3.08649\n",
      "开始预测用户1对电影7022的评分...\n",
      "预测出用户1对物品7022的评分：3.94114\n",
      "开始预测用户1对电影56174的评分...\n",
      "预测出用户1对物品56174的评分：3.36026\n",
      "开始预测用户1对电影47997的评分...\n",
      "预测出用户1对物品47997的评分：3.70979\n",
      "开始预测用户1对电影7046的评分...\n",
      "预测出用户1对物品7046的评分：2.64384\n",
      "开始预测用户1对电影31658的评分...\n",
      "预测出用户1对物品31658的评分：4.09935\n",
      "开始预测用户1对电影48043的评分...\n",
      "预测出用户1对物品48043的评分：3.71644\n",
      "开始预测用户1对电影7090的评分...\n",
      "预测出用户1对物品7090的评分：4.04504\n",
      "开始预测用户1对电影7099的评分...\n",
      "预测出用户1对物品7099的评分：4.20541\n",
      "开始预测用户1对电影72641的评分...\n",
      "预测出用户1对物品72641的评分：3.78598\n",
      "开始预测用户1对电影31685的评分...\n",
      "预测出用户1对物品31685的评分：3.18481\n",
      "开始预测用户1对电影97225的评分...\n",
      "预测出用户1对物品97225的评分：3.19729\n",
      "开始预测用户1对电影31696的评分...\n",
      "预测出用户1对物品31696的评分：3.36542\n",
      "开始预测用户1对电影48082的评分...\n",
      "预测出用户1对物品48082的评分：3.97459\n",
      "开始预测用户1对电影7143的评分...\n",
      "预测出用户1对物品7143的评分：3.84661\n",
      "开始预测用户1对电影7147的评分...\n",
      "预测出用户1对物品7147的评分：3.84177\n",
      "开始预测用户1对电影7149的评分...\n",
      "预测出用户1对物品7149的评分：3.42130\n",
      "开始预测用户1对电影7151的评分...\n",
      "预测出用户1对物品7151的评分：3.63348\n",
      "开始预测用户1对电影7153的评分...\n",
      "预测出用户1对物品7153的评分：4.21516\n",
      "开始预测用户1对电影7156的评分...\n",
      "预测出用户1对物品7156的评分：4.26288\n",
      "开始预测用户1对电影7160的评分...\n",
      "预测出用户1对物品7160的评分：3.31812\n",
      "开始预测用户1对电影7162的评分...\n",
      "预测出用户1对物品7162的评分：3.01996\n",
      "开始预测用户1对电影7163的评分...\n",
      "预测出用户1对物品7163的评分：2.97455\n",
      "开始预测用户1对电影7173的评分...\n",
      "预测出用户1对物品7173的评分：3.25838\n",
      "开始预测用户1对电影80906的评分...\n",
      "预测出用户1对物品80906的评分：4.69503\n",
      "开始预测用户1对电影97304的评分...\n",
      "预测出用户1对物品97304的评分：4.23866\n",
      "开始预测用户1对电影97306的评分...\n",
      "预测出用户1对物品97306的评分：3.51793\n",
      "开始预测用户1对电影105504的评分...\n",
      "预测出用户1对物品105504的评分：4.10075\n",
      "开始预测用户1对电影72737的评分...\n",
      "预测出用户1对物品72737的评分：3.91170\n",
      "开始预测用户1对电影56367的评分...\n",
      "预测出用户1对物品56367的评分：4.03294\n",
      "开始预测用户1对电影7247的评分...\n",
      "预测出用户1对物品7247的评分：3.10928\n",
      "开始预测用户1对电影7254的评分...\n",
      "预测出用户1对物品7254的评分：3.54715\n",
      "开始预测用户1对电影7265的评分...\n",
      "预测出用户1对物品7265的评分：3.74557\n",
      "开始预测用户1对电影64614的评分...\n",
      "预测出用户1对物品64614的评分：4.06793\n",
      "开始预测用户1对电影7293的评分...\n",
      "预测出用户1对物品7293的评分：3.57540\n",
      "开始预测用户1对电影31878的评分...\n",
      "预测出用户1对物品31878的评分：3.81237\n",
      "开始预测用户1对电影7317的评分...\n",
      "预测出用户1对物品7317的评分：2.77396\n",
      "开始预测用户1对电影7318的评分...\n",
      "预测出用户1对物品7318的评分：2.52784\n",
      "开始预测用户1对电影7323的评分...\n",
      "预测出用户1对物品7323的评分：3.47404\n",
      "开始预测用户1对电影7324的评分...\n",
      "预测出用户1对物品7324的评分：3.28857\n",
      "开始预测用户1对电影7325的评分...\n",
      "预测出用户1对物品7325的评分：3.39382\n",
      "开始预测用户1对电影48304的评分...\n",
      "预测出用户1对物品48304的评分：3.53675\n",
      "开始预测用户1对电影7346的评分...\n",
      "预测出用户1对物品7346的评分：2.71025\n",
      "开始预测用户1对电影7347的评分...\n",
      "预测出用户1对物品7347的评分：3.21041\n",
      "开始预测用户1对电影7360的评分...\n",
      "预测出用户1对物品7360的评分：3.94975\n",
      "开始预测用户1对电影7361的评分...\n",
      "预测出用户1对物品7361的评分：4.28907\n",
      "开始预测用户1对电影7367的评分...\n",
      "预测出用户1对物品7367的评分：2.27481\n",
      "开始预测用户1对电影187593的评分...\n",
      "预测出用户1对物品187593的评分：3.61947\n",
      "开始预测用户1对电影7371的评分...\n",
      "预测出用户1对物品7371的评分：3.92682\n",
      "开始预测用户1对电影64716的评分...\n",
      "预测出用户1对物品64716的评分：4.18396\n",
      "开始预测用户1对电影7373的评分...\n",
      "预测出用户1对物品7373的评分：3.36892\n",
      "开始预测用户1对电影7387的评分...\n",
      "预测出用户1对物品7387的评分：3.99430\n",
      "开始预测用户1对电影48385的评分...\n",
      "预测出用户1对物品48385的评分：3.52981\n",
      "开始预测用户1对电影48394的评分...\n",
      "预测出用户1对物品48394的评分：3.79697\n",
      "开始预测用户1对电影56587的评分...\n",
      "预测出用户1对物品56587的评分：3.63878\n",
      "开始预测用户1对电影7438的评分...\n",
      "预测出用户1对物品7438的评分：3.98120\n",
      "开始预测用户1对电影7439的评分...\n",
      "预测出用户1对物品7439的评分：3.19767\n",
      "开始预测用户1对电影7444的评分...\n",
      "预测出用户1对物品7444的评分：3.02532\n",
      "开始预测用户1对电影7445的评分...\n",
      "预测出用户1对物品7445的评分：3.30604\n",
      "开始预测用户1对电影7451的评分...\n",
      "预测出用户1对物品7451的评分：3.74654\n",
      "开始预测用户1对电影7454的评分...\n",
      "预测出用户1对物品7454的评分：2.85956\n",
      "开始预测用户1对电影32031的评分...\n",
      "预测出用户1对物品32031的评分：3.38657\n",
      "开始预测用户1对电影7458的评分...\n",
      "预测出用户1对物品7458的评分：3.42859\n",
      "开始预测用户1对电影72998的评分...\n",
      "预测出用户1对物品72998的评分：3.76434\n",
      "开始预测用户1对电影73017的评分...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测出用户1对物品73017的评分：3.97097\n",
      "开始预测用户1对电影7482的评分...\n",
      "预测出用户1对物品7482的评分：4.00004\n",
      "开始预测用户1对电影64839的评分...\n",
      "预测出用户1对物品64839的评分：3.84254\n",
      "开始预测用户1对电影81229的评分...\n",
      "预测出用户1对物品81229的评分：3.09540\n",
      "开始预测用户1对电影40278的评分...\n",
      "预测出用户1对物品40278的评分：3.74139\n",
      "开始预测用户1对电影105844的评分...\n",
      "预测出用户1对物品105844的评分：3.85933\n",
      "开始预测用户1对电影89470的评分...\n",
      "预测出用户1对物品89470的评分：3.79674\n",
      "开始预测用户1对电影48516的评分...\n",
      "预测出用户1对物品48516的评分：4.43904\n",
      "开始预测用户1对电影7569的评分...\n",
      "预测出用户1对物品7569的评分：3.55541\n",
      "开始预测用户1对电影89492的评分...\n",
      "预测出用户1对物品89492的评分：3.88814\n",
      "开始预测用户1对电影56757的评分...\n",
      "预测出用户1对物品56757的评分：3.74765\n",
      "开始预测用户1对电影64957的评分...\n",
      "预测出用户1对物品64957的评分：3.67481\n",
      "开始预测用户1对电影56775的评分...\n",
      "预测出用户1对物品56775的评分：2.87588\n",
      "开始预测用户1对电影64969的评分...\n",
      "预测出用户1对物品64969的评分：3.82177\n",
      "开始预测用户1对电影56782的评分...\n",
      "预测出用户1对物品56782的评分：4.13525\n",
      "开始预测用户1对电影64983的评分...\n",
      "预测出用户1对物品64983的评分：3.44609\n",
      "开始预测用户1对电影97752的评分...\n",
      "预测出用户1对物品97752的评分：3.69199\n",
      "开始预测用户1对电影114180的评分...\n",
      "预测出用户1对物品114180的评分：2.95978\n",
      "开始预测用户1对电影106002的评分...\n",
      "预测出用户1对物品106002的评分：3.64253\n",
      "开始预测用户1对电影65088的评分...\n",
      "预测出用户1对物品65088的评分：3.51018\n",
      "开始预测用户1对电影106072的评分...\n",
      "预测出用户1对物品106072的评分：3.22513\n",
      "开始预测用户1对电影48738的评分...\n",
      "预测出用户1对物品48738的评分：4.08159\n",
      "开始预测用户1对电影73321的评分...\n",
      "预测出用户1对物品73321的评分：3.11066\n",
      "开始预测用户1对电影179819的评分...\n",
      "预测出用户1对物品179819的评分：3.98105\n",
      "开始预测用户1对电影56941的评分...\n",
      "预测出用户1对物品56941的评分：3.62717\n",
      "开始预测用户1对电影106100的评分...\n",
      "预测出用户1对物品106100的评分：4.39311\n",
      "开始预测用户1对电影56949的评分...\n",
      "预测出用户1对物品56949的评分：3.37541\n",
      "开始预测用户1对电影97913的评分...\n",
      "预测出用户1对物品97913的评分：3.85388\n",
      "开始预测用户1对电影97921的评分...\n",
      "预测出用户1对物品97921的评分：3.73656\n",
      "开始预测用户1对电影48774的评分...\n",
      "预测出用户1对物品48774的评分：4.00105\n",
      "开始预测用户1对电影40583的评分...\n",
      "预测出用户1对物品40583的评分：3.44999\n",
      "开始预测用户1对电影48780的评分...\n",
      "预测出用户1对物品48780的评分：4.01138\n",
      "开始预测用户1对电影48783的评分...\n",
      "预测出用户1对物品48783的评分：3.56455\n",
      "开始预测用户1对电影89745的评分...\n",
      "预测出用户1对物品89745的评分：3.95735\n",
      "开始预测用户1对电影97938的评分...\n",
      "预测出用户1对物品97938的评分：4.06190\n",
      "开始预测用户1对电影81562的评分...\n",
      "预测出用户1对物品81562的评分：4.09065\n",
      "开始预测用户1对电影81564的评分...\n",
      "预测出用户1对物品81564的评分：3.61265\n",
      "开始预测用户1对电影89774的评分...\n",
      "预测出用户1对物品89774的评分：4.05995\n",
      "开始预测用户1对电影40629的评分...\n",
      "预测出用户1对物品40629的评分：3.14695\n",
      "开始预测用户1对电影81591的评分...\n",
      "预测出用户1对物品81591的评分：3.73819\n",
      "开始预测用户1对电影65230的评分...\n",
      "预测出用户1对物品65230的评分：3.34674\n",
      "开始预测用户1对电影48877的评分...\n",
      "预测出用户1对物品48877的评分：3.26341\n",
      "开始预测用户1对电影65261的评分...\n",
      "预测出用户1对物品65261的评分：4.62583\n",
      "开始预测用户1对电影89864的评分...\n",
      "预测出用户1对物品89864的评分：3.91506\n",
      "开始预测用户1对电影40732的评分...\n",
      "预测出用户1对物品40732的评分：3.48216\n",
      "开始预测用户1对电影89904的评分...\n",
      "预测出用户1对物品89904的评分：3.94254\n",
      "开始预测用户1对电影32587的评分...\n",
      "预测出用户1对物品32587的评分：3.95489\n",
      "开始预测用户1对电影40815的评分...\n",
      "预测出用户1对物品40815的评分：3.82129\n",
      "开始预测用户1对电影40819的评分...\n",
      "预测出用户1对物品40819的评分：3.76388\n",
      "开始预测用户1对电影81834的评分...\n",
      "预测出用户1对物品81834的评分：4.08631\n",
      "开始预测用户1对电影81845的评分...\n",
      "预测出用户1对物品81845的评分：4.10551\n",
      "开始预测用户1对电影81847的评分...\n",
      "预测出用户1对物品81847的评分：4.07352\n",
      "开始预测用户1对电影98243的评分...\n",
      "预测出用户1对物品98243的评分：4.25340\n",
      "开始预测用户1对电影114662的评分...\n",
      "预测出用户1对物品114662的评分：4.00647\n",
      "开始预测用户1对电影106487的评分...\n",
      "预测出用户1对物品106487的评分：3.44157\n",
      "开始预测用户1对电影3255的评分...\n",
      "预测出用户1对物品3255的评分：3.36496\n",
      "给用户1推荐的前10部电影的编号是：\n",
      "1041、714、80906、1235、3030、65261、1178、1217、318、1104、"
     ]
    }
   ],
   "source": [
    "def top_k_rs_result(k):\n",
    "    rating_matrix = load_data(DATA_PATH)\n",
    "    user_similar = compute_pearson_similarity(rating_matrix,based=\"user\")\n",
    "    results = predict_all(1,rating_matrix,user_similar,filter_rule=[\"unhot\",\"rated\"])\n",
    "    return sorted(results,key=lambda x:x[2],reverse=True)[:k]\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    k = 10\n",
    "    result = top_k_rs_result(10)\n",
    "    print(\"给用户1推荐的前10部电影的编号是：\")\n",
    "    for i in range(10):\n",
    "        print(result[i][1],end=\"、\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "movieId\n",
       "1       0.330978\n",
       "3       0.419564\n",
       "6       0.163510\n",
       "47      0.088477\n",
       "50      0.045364\n",
       "          ...   \n",
       "3740    0.273858\n",
       "3793    0.280298\n",
       "3809    0.126770\n",
       "4006    1.000000\n",
       "5060    0.218068\n",
       "Name: 2, Length: 190, dtype: float64"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "similar_items = item_similar[2].drop([2]).dropna()\n",
    "similar_items = similar_items.where(similar_items>0).dropna()\n",
    "if similar_items.empty is True:\n",
    "    raise Exception(f\"物品{iid}没有相似物品\")\n",
    "\n",
    " #找到uid对打分了的物品\n",
    "true_items = rating_matrix.loc[1].dropna()\n",
    "#从uid用户的近邻相似用户中筛选对iid用户有评分记录的用户\n",
    "fin_similar_items = true_items.index&similar_items.index\n",
    "fin_similar_items = similar_items[list(fin_similar_items)]\n",
    "fin_similar_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始加载数据...\n",
      "加载缓存中...\n",
      "从缓存中加载数据完毕...\n",
      "从缓存中加载物品相似度矩阵\n",
      "相似度矩阵处理完毕\n",
      "开始预测用户1对电影2的评分...\n",
      "预测出用户1对物品2的评分：4.35254\n",
      "4.35\n",
      "开始预测用户1对电影3的评分...\n",
      "预测出用户1对物品3的评分：4.56232\n",
      "4.56\n"
     ]
    }
   ],
   "source": [
    "#基于物品的推荐类似\n",
    "def predict(uid,iid,rating_matrix,item_similar):\n",
    "    '''\n",
    "    预测uid用户给iid商品的评分\n",
    "    :param uid: 用户Id\n",
    "    :param iid: 商品Id\n",
    "    :param rating_matrix: 用户-物品评分矩阵\n",
    "    :param user_similar:  物品-物品相似度矩阵\n",
    "    :return: 预测的评分值\n",
    "    '''\n",
    "    print(f\"开始预测用户{uid}对电影{iid}的评分...\")\n",
    "    \n",
    "    #找到和物品iid正相关的物品\n",
    "    similar_items = item_similar[iid].drop([iid]).dropna()\n",
    "    similar_items = similar_items.where(similar_items>0).dropna()\n",
    "    if similar_items.empty is True:\n",
    "        raise Exception(f\"物品{iid}没有相似物品\")\n",
    "    \n",
    "    #找到uid对打分了的物品\n",
    "    true_items = rating_matrix.loc[uid].dropna()\n",
    "    \n",
    "    #从uid用户的近邻相似用户中筛选对iid用户有评分记录的用户\n",
    "    fin_similar_items = true_items.index&similar_items.index\n",
    "    fin_similar_items = similar_items.loc[list(fin_similar_items)]\n",
    "    \n",
    "    #通过相关物品预测用户uid对iid物品评分\n",
    "    sum_up = 0 #预测公式的分子部分\n",
    "    sum_down = 0 #预测公式的分母部分\n",
    "    for sim_item_id,sim_value in fin_similar_items.items():\n",
    "        #用户对相似物品sim_item_id的评分\n",
    "        sim_item_rated_movies = rating_matrix[sim_item_id].loc[uid]\n",
    "        sum_up += sim_item_rated_movies * sim_value\n",
    "        sum_down += sim_value\n",
    "        \n",
    "    predict_rating = sum_up/sum_down\n",
    "    print(f\"预测出用户{uid}对物品{iid}的评分：{predict_rating:.5f}\")\n",
    "    return round(predict_rating,2)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    rating_matrix = load_data(DATA_PATH)\n",
    "    item_similar = compute_pearson_similarity(rating_matrix,based='item')\n",
    "    print(predict(1,2,rating_matrix,item_similar))\n",
    "    print(predict(1,3,rating_matrix,item_similar))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
